{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Network.Datadog.Metrics
  ( Series (..)
  , Metric (..)
  , MetricPoints (..)
  , sendMetrics
  , series
  , HasName(..)
  , HasPoints(..)
  , HasTags(..)
  , HasHost(..)
  , AsMetricPoints(..)
  ) where
import Control.Monad (void)
import Data.Aeson hiding (Series)
import Data.DList
import qualified Network.HTTP.Types  as HTTP
import qualified Network.HTTP.Client as C
import Network.Datadog.Internal

series :: [Metric] -> Series
series :: [Metric] -> Series
series = DList Metric -> Series
Series (DList Metric -> Series)
-> ([Metric] -> DList Metric) -> [Metric] -> Series
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Metric] -> DList Metric
forall a. [a] -> DList a
fromList

metricRequest :: C.Request
metricRequest :: Request
metricRequest = Request
baseRequest { method :: Method
C.method = Method
HTTP.methodPost
                            , path :: Method
C.path = Method
"/api/v1/series"
                            , requestHeaders :: RequestHeaders
C.requestHeaders = [(HeaderName
"Content-Type", Method
"application/json")]
                            }

sendMetrics :: DatadogCredentials k => DatadogClient k -> Series -> IO ()
sendMetrics :: DatadogClient k -> Series -> IO ()
sendMetrics DatadogClient k
m Series
s = IO (Response ()) -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO (Response ()) -> IO ()) -> IO (Response ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ Request -> Manager -> IO (Response ())
C.httpNoBody Request
req (Manager -> IO (Response ())) -> Manager -> IO (Response ())
forall a b. (a -> b) -> a -> b
$ DatadogClient k -> Manager
forall a. DatadogClient a -> Manager
datadogClientManager DatadogClient k
m
  where
    req :: Request
req = (k -> Request -> Request
forall s. DatadogCredentials s => s -> Request -> Request
signRequest (DatadogClient k -> k
forall a. DatadogClient a -> a
datadogClientKeys DatadogClient k
m) Request
metricRequest) { requestBody :: RequestBody
C.requestBody = ByteString -> RequestBody
C.RequestBodyLBS (ByteString -> RequestBody) -> ByteString -> RequestBody
forall a b. (a -> b) -> a -> b
$ Series -> ByteString
forall a. ToJSON a => a -> ByteString
encode Series
s }

-- | Wall clock time
{-
withTimingMetric :: DatadogCredentials k => DatadogClient k
                 -> (Metric -> IO ())
                 -> Text        -- ^ metric
                 -> Maybe Text  -- ^ hostname
                 -> [Text]      -- ^ tags
                 -> IO a
                 -> IO a
withTimingMetric mAction m h ts action = do
  t <- getCurrentTime
  r <- action
  t' <- getCurrentTime
  mAction $ Metric m [Counter diff]diffUTCTime t' t
-}