Popularity

8.3

Stable

Activity

3.5

Declining

Stars 31

Watchers 13

Forks 7

Last Commit over 1 year ago

Monthly Downloads: 26

Programming language: Haskell

License: MIT License

Tags: Control Web Monad

Latest version: v0.2.2.0

monad-metrics alternatives and similar packages

Based on the "monad" category.
Alternatively, view monad-metrics alternatives based on common mentions on social networks and blogs.

monad-validate

9.1 0.0 monad-metrics VS monad-validate

DISCONTINUED. (NOTE: REPOSITORY MOVED TO NEW OWNER: https://github.com/lexi-lambda/monad-validate) A Haskell monad transformer library for data validation
monad-control

9.0 0.0 monad-metrics VS monad-control

Lift control operations, like exception catching, through monad transformers

InfluxDB – Built for High-Performance Time Series Workloads

InfluxDB 3 OSS is now GA. Transform, enrich, and act on time series data directly in the database. Automate critical tasks and eliminate the need to move data externally. Download now.

Promo www.influxdata.com

monad-time

8.9 4.6 monad-metrics VS monad-time

Type class for monads which carry the notion of the current time.
monad-unlift

8.5 0.0 monad-metrics VS monad-unlift

Typeclasses for representing monad (transformer) morphisms
monad-unlift-ref

8.5 0.0 monad-metrics VS monad-unlift-ref

Typeclasses for representing monad (transformer) morphisms
monad-loops

8.2 0.0 monad-metrics VS monad-loops

Some useful control operators for looping
monad-memo

7.6 0.0 monad-metrics VS monad-memo

Memoization monad transformer
monad-skeleton

7.6 0.0 monad-metrics VS monad-skeleton

Operational monad library
monad-logger-prefix

7.5 0.0 monad-metrics VS monad-logger-prefix

Easily add a prefix to your MonadLogger output.
monad-batcher

6.9 0.0 monad-metrics VS monad-batcher

An applicative monad that batches commands for later more efficient execution
monad-ste

6.6 0.0 monad-metrics VS monad-ste

ST with efficient exceptions
monad-supply

6.0 2.6 monad-metrics VS monad-supply

Support for computations which consume values from a (possibly infinite) supply.
monad-classes

5.8 0.0 monad-metrics VS monad-classes

A more flexible mtl
monad-io-adapter

5.8 0.0 monad-metrics VS monad-io-adapter

DISCONTINUED. A Haskell package that adapts between MonadIO and MonadBase IO [GET https://api.github.com/repos/cjdev/monad-io-adapter: 404 - Not Found // See: https://docs.github.com/rest/repos/repos#get-a-repository]
monad-task

5.1 0.0 monad-metrics VS monad-task

Task monad transformer that turns event processing into co-routines programming.
monad-journal

4.3 0.0 monad-metrics VS monad-journal

Pure logger typeclass and monad transformer
monad-extras

4.1 0.0 monad-metrics VS monad-extras

Extra utility functions for working with monads
monad-levels

4.0 0.0 monad-metrics VS monad-levels

Level-based interpretation of monad transformers
monad-resumption

3.9 0.0 monad-metrics VS monad-resumption

Resumption and Reactive-Resumption Monads for the Haskell programming language.
monad-st

3.8 0.0 monad-metrics VS monad-st

A basic monad for lifting ST actions
monad-loops-stm

3.5 0.0 monad-metrics VS monad-loops-stm

STM-specific control operators (split out of monad-loops as of version 0.4)
monad-peel

2.9 5.5 monad-metrics VS monad-peel

Lift control operations like exception catching through monad transformers
monad-interleave

2.7 0.0 monad-metrics VS monad-interleave

Monads with an unsaveInterleaveIO-like operation
monad-introspect

2.4 0.0 monad-metrics VS monad-introspect

A reader monad that gives the environment access to the entire transformer stack
monad-control-aligned

2.2 0.0 monad-metrics VS monad-control-aligned

Lift control operations, like exception catching, through monad transformers
io-manager

2.1 0.0 monad-metrics VS io-manager

DISCONTINUED. Skeleton library around the IO monad.
monad-open

2.0 0.0 monad-metrics VS monad-open

Open-ended computation for when you need it (open recursion)
monad-var

1.7 0.0 monad-metrics VS monad-var

Generic operations over variables
monad-finally

1.1 2.9 monad-metrics VS monad-finally

Guard monadic computations with cleanup actions
monad-control-identity

1.0 0.0 monad-metrics VS monad-control-identity

Stronger classes than monad-control
monad-markov

0.5 0.0 monad-metrics VS monad-markov

Markov process monad

Do you think we are missing an alternative of monad-metrics or a related project?

Add another 'monad' Package

Popular Comparisons

README

`monad-metrics`

This library defines a convenient wrapper and API for using EKG metrics in your application. It's heavily inspired by the metrics code that Taylor Fausak used in his Haskell application blunt.

Usage

This README is an executable literate Haskell file. If you have stack installed, then you can run the file with:

./README.lhs

We'll need to start with the import/pragma boilerplate:

{-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE NoMonomorphismRestriction #-} import qualified Control.Monad.Metrics as Metrics import Control.Monad.Metrics (Metrics, Resolution(..), MonadMetrics(..)) import Control.Monad.Reader import qualified System.Metrics as EKG

The Control.Monad.Metrics module is designed to be imported qualified.

Initialize!

First, you need to initialize the Metrics data type. You can do so using initialize (to create a new EKG store) or initializeWith if you want to pass a preexisting store.

initializing :: Bool -> EKG.Store -> IO Metrics initializing True store = Metrics.initializeWith store initializing False _ = Metrics.initialize

Embed!

The next step is to implement an instance of the class MonadMetrics for your monad transformer stack. This library has explicitly decided not to provide a concrete monad transformer to reduce the dependency footprint. Fortunately, it's pretty easy!

Suppose you've got the following stack:

type App = ReaderT Config IO data Config = Config { configMetrics :: Metrics }

then you can easily get the required instance with:

instance MonadMetrics (ReaderT Config IO) where getMetrics = asks configMetrics

Now, you're off to the races! Let's record some metrics.

If you're after a really simple embedding, you can use run or run':

simple :: Int -> IO () simple i = Metrics.run $ do metrics <- Metrics.getMetrics Metrics.gauge "Simple" i forM_ [1..i] $ \_ -> do Metrics.increment "Count!" gettingThere :: IO () gettingThere = Metrics.run' (\metrics -> Config metrics) $ do liftIO $ putStrLn "it accepts a constructor"

Measure!

Once your application has the required instance, you can use EKG's metrics (counters, gauges, labels, distributions).

For detailed descriptions of the various metric types, see the corresponding EKG documentation:

Generally, the library provides "sane default" functions which accept the name of the metric to work with and the value to contribute to that metric.

w = Metrics.label "Foo" "Bar" x = Metrics.counter "MetricName" 6 y = Metrics.distribution "Distribute" 3.4 z = Metrics.gauge "Gauge" 7

Generalized versions of these functions are available with an apostrophe. Labels accept any Showable value, while gauges and counters accept any Integral value.

a = Metrics.label' "List" [1,2,3] b = Metrics.counter' "Count" (3 :: Integer)

Timers

You can time actions with timed, which has a resolution of seconds. You can use timed' which accepts a Resolution argument to provide a different scale.

timedProcess :: App Int timedProcess = Metrics.timed "summing1" $ do pure $! sum [1 .. 100000] timedInMilliseconds :: App Int timedInMilliseconds = Metrics.timed' Microseconds "summing2" $ do pure $! sum [1..100]

A demonstration

main :: IO () main = do metrics <- Metrics.initialize flip runReaderT (Config metrics) $ do Metrics.label "ProgramName" "README" forM_ [1..10] $ \_ -> do Metrics.increment "up-to-ten" Metrics.timed' Nanoseconds "Whatever" $ do liftIO $ putStrLn "Hello World!"

monad-metrics

haskell metrics