{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module System.Metrics.Prometheus.RegistryT where

import Control.Applicative ((<$>))
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Trans.Class (MonadTrans)
import Control.Monad.Trans.State.Strict (
    StateT (..),
    evalStateT,
    execStateT,
    get,
 )

import System.Metrics.Prometheus.Metric.Counter (Counter)
import System.Metrics.Prometheus.Metric.Gauge (Gauge)
import System.Metrics.Prometheus.Metric.Histogram (Histogram)
import qualified System.Metrics.Prometheus.Metric.Histogram as Histogram
import System.Metrics.Prometheus.MetricId (
    Labels,
    MetricId,
    Name,
 )
import System.Metrics.Prometheus.Registry (
    Registry,
    RegistrySample,
    new,
 )
import qualified System.Metrics.Prometheus.Registry as R


newtype RegistryT m a = RegistryT {forall (m :: * -> *) a. RegistryT m a -> StateT Registry m a
unRegistryT :: StateT Registry m a}
    deriving (forall a. a -> RegistryT m a
forall a b. RegistryT m a -> RegistryT m b -> RegistryT m b
forall a b. RegistryT m a -> (a -> RegistryT m b) -> RegistryT m b
forall {m :: * -> *}. Monad m => Applicative (RegistryT m)
forall (m :: * -> *) a. Monad m => a -> RegistryT m a
forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> RegistryT m b -> RegistryT m b
forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> (a -> RegistryT m b) -> RegistryT m b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> RegistryT m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> RegistryT m a
>> :: forall a b. RegistryT m a -> RegistryT m b -> RegistryT m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> RegistryT m b -> RegistryT m b
>>= :: forall a b. RegistryT m a -> (a -> RegistryT m b) -> RegistryT m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> (a -> RegistryT m b) -> RegistryT m b
Monad, forall (m :: * -> *) a. Monad m => m a -> RegistryT m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: forall (m :: * -> *) a. Monad m => m a -> RegistryT m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> RegistryT m a
MonadTrans, forall a. a -> RegistryT m a
forall a b. RegistryT m a -> RegistryT m b -> RegistryT m a
forall a b. RegistryT m a -> RegistryT m b -> RegistryT m b
forall a b. RegistryT m (a -> b) -> RegistryT m a -> RegistryT m b
forall a b c.
(a -> b -> c) -> RegistryT m a -> RegistryT m b -> RegistryT m c
forall {m :: * -> *}. Monad m => Functor (RegistryT m)
forall (m :: * -> *) a. Monad m => a -> RegistryT m a
forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> RegistryT m b -> RegistryT m a
forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> RegistryT m b -> RegistryT m b
forall (m :: * -> *) a b.
Monad m =>
RegistryT m (a -> b) -> RegistryT m a -> RegistryT m b
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> RegistryT m a -> RegistryT m b -> RegistryT m c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b. RegistryT m a -> RegistryT m b -> RegistryT m a
$c<* :: forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> RegistryT m b -> RegistryT m a
*> :: forall a b. RegistryT m a -> RegistryT m b -> RegistryT m b
$c*> :: forall (m :: * -> *) a b.
Monad m =>
RegistryT m a -> RegistryT m b -> RegistryT m b
liftA2 :: forall a b c.
(a -> b -> c) -> RegistryT m a -> RegistryT m b -> RegistryT m c
$cliftA2 :: forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> RegistryT m a -> RegistryT m b -> RegistryT m c
<*> :: forall a b. RegistryT m (a -> b) -> RegistryT m a -> RegistryT m b
$c<*> :: forall (m :: * -> *) a b.
Monad m =>
RegistryT m (a -> b) -> RegistryT m a -> RegistryT m b
pure :: forall a. a -> RegistryT m a
$cpure :: forall (m :: * -> *) a. Monad m => a -> RegistryT m a
Applicative, forall a b. a -> RegistryT m b -> RegistryT m a
forall a b. (a -> b) -> RegistryT m a -> RegistryT m b
forall (m :: * -> *) a b.
Functor m =>
a -> RegistryT m b -> RegistryT m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> RegistryT m a -> RegistryT m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> RegistryT m b -> RegistryT m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> RegistryT m b -> RegistryT m a
fmap :: forall a b. (a -> b) -> RegistryT m a -> RegistryT m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> RegistryT m a -> RegistryT m b
Functor, forall a. IO a -> RegistryT m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall {m :: * -> *}. MonadIO m => Monad (RegistryT m)
forall (m :: * -> *) a. MonadIO m => IO a -> RegistryT m a
liftIO :: forall a. IO a -> RegistryT m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> RegistryT m a
MonadIO)


evalRegistryT :: Monad m => RegistryT m a -> m a
evalRegistryT :: forall (m :: * -> *) a. Monad m => RegistryT m a -> m a
evalRegistryT = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT Registry
new forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. RegistryT m a -> StateT Registry m a
unRegistryT


execRegistryT :: Monad m => RegistryT m a -> m Registry
execRegistryT :: forall (m :: * -> *) a. Monad m => RegistryT m a -> m Registry
execRegistryT = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m s
execStateT Registry
new forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. RegistryT m a -> StateT Registry m a
unRegistryT


runRegistryT :: Monad m => RegistryT m a -> m (a, Registry)
runRegistryT :: forall (m :: * -> *) a. Monad m => RegistryT m a -> m (a, Registry)
runRegistryT = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT Registry
new forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. RegistryT m a -> StateT Registry m a
unRegistryT


withRegistry :: MonadIO m => (Registry -> m (a, Registry)) -> RegistryT m a
withRegistry :: forall (m :: * -> *) a.
MonadIO m =>
(Registry -> m (a, Registry)) -> RegistryT m a
withRegistry = forall (m :: * -> *) a. StateT Registry m a -> RegistryT m a
RegistryT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT


registerCounter :: MonadIO m => Name -> Labels -> RegistryT m Counter
registerCounter :: forall (m :: * -> *).
MonadIO m =>
Name -> Labels -> RegistryT m Counter
registerCounter Name
n Labels
l = forall (m :: * -> *) a.
MonadIO m =>
(Registry -> m (a, Registry)) -> RegistryT m a
withRegistry (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Labels -> Registry -> IO (Counter, Registry)
R.registerCounter Name
n Labels
l)


registerGauge :: MonadIO m => Name -> Labels -> RegistryT m Gauge
registerGauge :: forall (m :: * -> *).
MonadIO m =>
Name -> Labels -> RegistryT m Gauge
registerGauge Name
n Labels
l = forall (m :: * -> *) a.
MonadIO m =>
(Registry -> m (a, Registry)) -> RegistryT m a
withRegistry (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Labels -> Registry -> IO (Gauge, Registry)
R.registerGauge Name
n Labels
l)


registerHistogram :: MonadIO m => Name -> Labels -> [Histogram.UpperBound] -> RegistryT m Histogram
registerHistogram :: forall (m :: * -> *).
MonadIO m =>
Name -> Labels -> [UpperBound] -> RegistryT m Histogram
registerHistogram Name
n Labels
l [UpperBound]
u = forall (m :: * -> *) a.
MonadIO m =>
(Registry -> m (a, Registry)) -> RegistryT m a
withRegistry (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name
-> Labels -> [UpperBound] -> Registry -> IO (Histogram, Registry)
R.registerHistogram Name
n Labels
l [UpperBound]
u)


removeMetric :: MonadIO m => MetricId -> RegistryT m ()
removeMetric :: forall (m :: * -> *). MonadIO m => MetricId -> RegistryT m ()
removeMetric MetricId
i = forall (m :: * -> *) a.
MonadIO m =>
(Registry -> m (a, Registry)) -> RegistryT m a
withRegistry (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. (,) () forall b c a. (b -> c) -> (a -> b) -> a -> c
. MetricId -> Registry -> Registry
R.removeMetric MetricId
i)


listMetricIds :: MonadIO m => RegistryT m [MetricId]
listMetricIds :: forall (m :: * -> *). MonadIO m => RegistryT m [MetricId]
listMetricIds = Registry -> [MetricId]
R.listMetricIds forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. StateT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) s. Monad m => StateT s m s
get


sample :: Monad m => RegistryT m (IO RegistrySample)
sample :: forall (m :: * -> *). Monad m => RegistryT m (IO RegistrySample)
sample = Registry -> IO RegistrySample
R.sample forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. StateT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) s. Monad m => StateT s m s
get