{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module System.Metrics.Prometheus.Concurrent.RegistryT where

import Control.Applicative ((<$>))
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Trans.Class (MonadTrans)
import Control.Monad.Trans.Reader (
    ReaderT (..),
    ask,
 )

import System.Metrics.Prometheus.Concurrent.Registry (Registry, new)
import qualified System.Metrics.Prometheus.Concurrent.Registry as R
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 (
    RegistrySample,
    listMetricIds,
 )


newtype RegistryT m a = RegistryT {forall (m :: * -> *) a. RegistryT m a -> ReaderT Registry m a
unRegistryT :: ReaderT 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 (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 {m :: * -> *}. Applicative m => Functor (RegistryT m)
forall (m :: * -> *) a. Applicative m => a -> RegistryT m a
forall (m :: * -> *) a b.
Applicative m =>
RegistryT m a -> RegistryT m b -> RegistryT m a
forall (m :: * -> *) a b.
Applicative m =>
RegistryT m a -> RegistryT m b -> RegistryT m b
forall (m :: * -> *) a b.
Applicative m =>
RegistryT m (a -> b) -> RegistryT m a -> RegistryT m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> RegistryT m a -> RegistryT m b -> RegistryT m c
<* :: forall a b. RegistryT m a -> RegistryT m b -> RegistryT m a
$c<* :: forall (m :: * -> *) a b.
Applicative 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.
Applicative 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.
Applicative 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.
Applicative m =>
RegistryT m (a -> b) -> RegistryT m a -> RegistryT m b
pure :: forall a. a -> RegistryT m a
$cpure :: forall (m :: * -> *) a. Applicative 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)


runRegistryT :: MonadIO m => RegistryT m a -> m a
runRegistryT :: forall (m :: * -> *) a. MonadIO m => RegistryT m a -> m a
runRegistryT RegistryT m a
registry = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO Registry
new forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (forall (m :: * -> *) a. RegistryT m a -> ReaderT Registry m a
unRegistryT RegistryT m a
registry)


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. ReaderT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) r. Monad m => ReaderT r m r
ask forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 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
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. ReaderT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) r. Monad m => ReaderT r m r
ask forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 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
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]
b = forall (m :: * -> *) a. ReaderT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) r. Monad m => ReaderT r m r
ask forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 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
R.registerHistogram Name
n Labels
l [UpperBound]
b


removeMetric :: MonadIO m => MetricId -> RegistryT m ()
removeMetric :: forall (m :: * -> *). MonadIO m => MetricId -> RegistryT m ()
removeMetric MetricId
i = forall (m :: * -> *) a. ReaderT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) r. Monad m => ReaderT r m r
ask forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. MetricId -> Registry -> IO ()
R.removeMetric MetricId
i


listMetricIds :: MonadIO m => RegistryT m [MetricId]
listMetricIds :: forall (m :: * -> *). MonadIO m => RegistryT m [MetricId]
listMetricIds = forall (m :: * -> *) a. ReaderT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) r. Monad m => ReaderT r m r
ask forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. Registry -> IO [MetricId]
R.listMetricIds


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. ReaderT Registry m a -> RegistryT m a
RegistryT forall (m :: * -> *) r. Monad m => ReaderT r m r
ask