yeller- A Yeller Client For Haskell

Safe HaskellNone




data ErrorNotification a Source

An error notification. This is what is sent to Yeller's servers




errorType :: Text

The type of the error. E.g. SomeException, DivideByZero

errorMessage :: Text

The message of the exception

errorStackTrace :: [StackFrame]

The stacktrace of the error. Usually grabbed using whoCreated

errorHost :: Text

The host that this error occurred on

errorEnvironment :: Text

The application environment this error occurred in

errorClientVersion :: Text

The version of the yeller client reporting the error

errorExtra :: ExtraErrorInfo a

See ExtraErrorInfo

data StackFrame Source

A line of the stacktrace




stackFilename :: Text

The filename this line occurred in

stackLineNumber :: Text

The line number(s) this line occurred in

stackFunction :: Text

The function this line occurred in

stackOptions :: StackOptions

data StackOptions Source

Options to be associated with each line in the stacktrace. Currently only supports if the line is in the application or not.



data ExtraErrorInfo a Source

Extra error information to be passed along with an error. All fields are optional.




errorURL :: Maybe Text

If the error happened during a web request, the url that was hit during that request

errorCustomData :: Maybe (Map Text a)

A map of data that has to conform to Aeson's ToJSON typeclass. Can be anything you want that helps you debug the error.

errorLocation :: Maybe Text

What toplevel part of the application the request that caused the error came from e.g. web controller name, background job name

errorUser :: Maybe UserInfo

Which user the error happened from. Lets you see how many total users were affected by an error

errorHTTPRequest :: Maybe HTTPRequest

Which http request was happening when the error occurred


data UserInfo Source

Lets you attach which user the error happened with which lets you count the total number of affected users




userID :: Integer

The user id of the affected user

emptyExtraErrorInfo :: ExtraErrorInfo Int Source

Extra error info with all fields turned off.

Useful when getting started, but real apps should fill in as many fields as possible for better debugging context

data HTTPRequest Source

Lets you attach which http request was occurring when the error happened which lets you see the browser, if the request came from a spider and so on




httpRequestUserAgent :: Text

The user agent of the impacted http request

maybeOr :: Maybe a -> a -> a Source

newtype Backend Source

An endpoint to send errors with. Must end with "/" sample:

Backend ""


Backend Text 

data YellerClient Source

A Yeller client. Build one with client like so: client (defaultClientSettings { clientSettingsToken = YellerToken YOUR_TOKEN_HERE })

Used to keep persistent http connections alive, keep track of which endpoint to send to, and a bunch of data that's sent along with the error.




clientToken :: Text

The token used to authenticate with Yeller's servers.

clientHost :: Text

The server this client is running on.

clientEnvironment :: Text

The environment this client is running in

clientVersion :: Text

The version number of this client

clientApplicationPackage :: Text

The name of the application package that is using this client

clientManager :: Manager

The http manager for tracking open connections

clientBackends :: TVar [Backend]

The set of backends to use. The next backend that will be used is second in the list.

clientErrorHandler :: YellerClientErrorHandler

The client error handler. See YellerClientErrorHandler

clientMaxRetries :: Int

The maximum number of retries


data YellerClientErrorHandler Source

An error handler, for dealing with errors when sending errors to Yeller's servers defaultErrorHandler just prints to stderr when receiving errors, but you might want to override that to make it go to your logging system of choice.




handleAuthenticationErrors :: Response BodyReader -> IO ()

Used when handling authentication (401, 403) failures from Yeller's servers. These errors are *not* retried like other ones.

handleIOErrors :: SomeException -> ErrorNotification Value -> IO ()

Used when handling any errors that aren't authentication related. This function will only be called after clientMaxRetries is exceeded.

data ApplicationEnvironment Source

The Environment your client is running in. If set to TestEnvironment, then no errors will be reported (which you should do for development/testing)



Clients constructed with this environment don't send errors.

ApplicationEnvironment Text

Any client in this kind of environment will report errors.

newtype ApplicationPackage Source

The name of the package your application is in.


ApplicationPackage Text 

newtype YellerToken Source

An api token. Get one from your project's settings page


YellerToken Text 

data YellerClientSettings Source

Options you pass when creating a client, usually done like this:

client (defaultClientSettings { clientSettingsToken = YellerToken "YOUR_TOKEN_HERE" })




clientSettingsToken :: YellerToken

The api token used for authenticating with Yeller's servers

clientSettingsHost :: Maybe Text

(optional): the name of the server this client is running on if set to Nothing, client will default it to getHostName

clientSettingsEnvironment :: ApplicationEnvironment

The name of the environment the application is running in for example: production, test etc if set to TestEnvironment, the client will be disabled

clientSettingsApplicationPackage :: ApplicationPackage

The name of the application package, used to filter out noisy stacktrace lines by default in the UI. Lines from functions starting with this are marked as "in-app", others will only show up via a toggle in the UI.

clientSettingsBackends :: [Backend]

A list of servers to contact. Weird things will probably happen if it's set to []

clientSettingsErrorHandler :: YellerClientErrorHandler

Used for handling errors when sending to Yeller's servers. See YellerClientErrorHandler for more.

clientSettingsMaxRetries :: Int

The maximum number of times to retry sending to the servers before logging a failure. Weird things will probably happen if set to less than 1.

defaultClientSettings :: YellerClientSettings Source

The default client settings, used for constructing a client

defaultErrorHandler :: YellerClientErrorHandler Source

The default error handler, which logs errors when sending things to Yeller to stderr

class (Typeable a, Show a) => ToError a where Source

A class for converting things into errors. Means you can pass both exceptions, and any other error like values in your code.

sendError :: (ToError e, ToJSON a) => YellerClient -> e -> ExtraErrorInfo a -> IO () Source

Sends an error to Yeller's servers needs a client, something that can be turned into an error (via ToError), and extra error information (which describes additional information to be sent along with the error). See ExtraErrorInfo for the extra info, and client for how to create a client.

Sample invocation:

sendError yellerClient someError emptyExtraErrorInfo

modifyTVar_ :: TVar a -> (a -> a) -> STM () Source

client :: YellerClientSettings -> IO YellerClient Source

Initializes a Yeller client, given some client settings Call it like this with the default client settings:

client (defaultClientSettings { clientSettingsToken = YellerToken "YOUR_TOKEN_HERE" })