Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Prometheus Haskell Client

Prometheus Haskell Client

A simple and modern, type safe, performance focused, idiomatic Haskell client for Prometheus monitoring. Specifically there is no use of unsafe IO or manual ByteString construction from lists of bytes. Batteries-included web server. A key design element of this library is that the RegistryT monad transformer is only required for registering new time series. Once the time series is registered, new data samples may just be added in the IO monad. Note: Version 0.* supports Prometheus v1.0 and version 2.* supports Prometheus v2.0.

Usage Example

module Example where

import           Control.Monad.IO.Class                         (liftIO)
import           System.Metrics.Prometheus.Http.Scrape          (serveMetricsT)
import           System.Metrics.Prometheus.Concurrent.RegistryT
import           System.Metrics.Prometheus.Metric.Counter       (inc)
import           System.Metrics.Prometheus.MetricId

main :: IO ()
main = runRegistryT $ do
-- Labels can be defined as lists or added to an empty label set
connectSuccessGauge <- registerGauge "example_connections" (fromList [("login", "success")])
connectFailureGauge <- registerGauge "example_connections" (addLabel "login" "failure" mempty)
connectCounter <- registerCounter "example_connection_total" mempty
latencyHistogram <- registerHistogram "example_round_trip_latency_ms" mempty [10, 20..100]

liftIO $ inc connectCounter -- increment a counter

-- [...] pass metric handles to the rest of the app

serveMetricsT 8080 ["metrics"] -- http://localhost:8080/metric server

Advanced Usage

A Registry and StateT-based RegistryT are available for unit testing or generating lists of `[IO a]` actions that can be sequenced and returned from pure code to be applied.

package promises

Lazy demand-driven promises Lazy demand-driven promises
package prospect

Explore continuations with trepidation Please see the README on GitHub at https://github.com/isovector/prospect#readme
package protobuf

Google Protocol Buffers via GHC.Generics Google Protocol Buffers via GHC.Generics. Protocol Buffers are a way of encoding structured data in an efficient yet extensible format. Google uses Protocol Buffers for almost all of its internal RPC protocols and file formats. This library supports a useful subset of Google Protocol Buffers message specifications in a Haskell. No preprocessor or additional build steps are required for message encoding and decoding. Record specifications are built by defining records with specially defined fields that capture most of the Protocol Buffers specification language.
package protobuf-simple

Simple Protocol Buffers library (proto2) An Haskell implementation of Google's Protocol Buffers version 2 with an emphasis on simplicity. The implementation consists of a library for encoding and decoding of data and the `protobuf-simple-protoc` executable for generating Haskell types from proto files. In fact, the types that are used in the tests are generated with the following command:
```
$ protobuf-simple-protoc data/Types.proto
```
In the example below, the CustomType is a Haskell type that was generated with the `protobuf-simple-protoc` executable. The encCustomType function encodes a CustomType into a ByteString. The decCustomType function decodes a ByteString into either a CustomType or an error.
```
module Codec where

import Data.ByteString.Lazy (ByteString)
import Data.ProtoBuf (decode, encode)
import Types.CustomType (CustomType(..))

encCustomType :: CustomType -> ByteString
encCustomType = encode

decCustomType :: ByteString -> Either String CustomType
decCustomType = decode
```
The library exposes two modules, Data.ProtoBuf, which is used for encoding and decoding and Data.ProtoBufInt, which is an internal module that is used by the generated types.
package protocol-radius

parser and printer for radius protocol packet This package provides parser and printer for radius protocol packet.
package protocol-radius-test

testsuit of protocol-radius haskell package This package provides testsuit of protocol-radius haskell package.
package pseudo-boolean

Reading/Writing OPB/WBO files used in pseudo boolean competition Reading/Writing OPB/WBO files used in pseudo boolean competition
package pthread

Bindings for the pthread library. Bindings for the pthread library.
package pulse-simple

binding to Simple API of pulseaudio Binding to simple version of client API for the pulseaudio soundserver. Although it does not provide advanced features and some not-so-adavanced features like volume control, it should be enough for simple applications. Confirmed to work on linux(32 bit and 64 bit) with ghc 6.8, 6.10, 7.0.4.

Page 231 of many | Previous | Next