Servant.Util.Combinators.Logging

Allows to enable logging of requests and responses.

Automatic requests logging

data LoggingApi config api

Enables logging for server which serves given api.

config is a type at which you have to specify ServantLogConfig via reflection. This way was chosen because the least thing we need in config is LoggerName, and we want to have <> on LoggerNames thus KnownSymbol is not enough.

This logging will report

• Request parameters, including request bodies
• If execution failed with error, it will be displayed
• Details like request method and endpoint execution time

If user makes request which is not defined it won't be logged. However, I don't find it a great problem, it may impede only in development or on getting acknowledged with api.

Instances

(HasServer (LoggingApiRec config api) ctx, HasServer api ctx) => HasServer (LoggingApi config api :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Associated Types

type ServerT (LoggingApi config api) m

Methods

route :: Proxy (LoggingApi config api) -> Context ctx -> Delayed env (Server (LoggingApi config api)) -> Router env

hoistServerWithContext :: Proxy (LoggingApi config api) -> Proxy ctx -> (forall x. m x -> n x) -> ServerT (LoggingApi config api) m -> ServerT (LoggingApi config api) n

type ServerT (LoggingApi config api :: Type) m

Defined in Servant.Util.Combinators.Logging

type ServerT (LoggingApi config api :: Type) m = ServerT api m

data LoggingApiRec config api

Helper to traverse servant api and apply logging.

Instances

HasLoggingServer config api ctx => HasServer (LoggingApiRec config api :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Associated Types

type ServerT (LoggingApiRec config api) m

Methods

route :: Proxy (LoggingApiRec config api) -> Context ctx -> Delayed env (Server (LoggingApiRec config api)) -> Router env

hoistServerWithContext :: Proxy (LoggingApiRec config api) -> Proxy ctx -> (forall x. m x -> n x) -> ServerT (LoggingApiRec config api) m -> ServerT (LoggingApiRec config api) n

type ServerT (LoggingApiRec config api :: Type) m

Defined in Servant.Util.Combinators.Logging

type ServerT (LoggingApiRec config api :: Type) m

class HasServer api ctx => HasLoggingServer config api ctx where

Version of HasServer which is assumed to perform logging. It's helpful because 'ServerT (LoggingApi ...)' is already defined for us in actual HasServer instance once and forever.

Methods

routeWithLog :: Proxy (LoggingApiRec config api) -> Context ctx -> Delayed env (Server (LoggingApiRec config api)) -> Router env

Instances

HasLoggingServer (config :: k) Raw ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config Raw) -> Context ctx -> Delayed env (Server (LoggingApiRec config Raw)) -> Router env

(HasServer (NoContentVerb mt) ctx, Reifies config ServantLogConfig, ReflectMethod mt) => HasLoggingServer (config :: k1) (NoContentVerb mt :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (NoContentVerb mt)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (NoContentVerb mt))) -> Router env

(HasLoggingServer config api1 ctx, HasLoggingServer config api2 ctx) => HasLoggingServer (config :: k) (api1 :<|> api2 :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (api1 :<|> api2)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (api1 :<|> api2))) -> Router env

HasLoggingServer config res ctx => HasLoggingServer (config :: k) (Description d :> res :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (Description d :> res)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (Description d :> res))) -> Router env

HasLoggingServer config res ctx => HasLoggingServer (config :: k) (Summary s :> res :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (Summary s :> res)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (Summary s :> res))) -> Router env

(HasLoggingServer config res ctx, KnownSymbol s) => HasLoggingServer (config :: k) (QueryFlag s :> res :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (QueryFlag s :> res)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (QueryFlag s :> res))) -> Router env

(KnownSymbol path, HasLoggingServer config res ctx) => HasLoggingServer (config :: k) (path :> res :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (path :> res)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (path :> res))) -> Router env

(HasServer (subApi :> res) ctx, HasServer (subApi :> LoggingApiRec config res) ctx, ApiHasArg subApi res, ApiHasArg subApi (LoggingApiRec config res), ApiCanLogArg subApi, Buildable (ApiArgToLog subApi), subApi ~ apiType a) => HasLoggingServer (config :: k) (apiType a :> res :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (apiType a :> res)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (apiType a :> res))) -> Router env

(HasServer (Verb mt st ct a) ctx, Reifies config ServantLogConfig, ReflectMethod mt, Buildable (ForResponseLog a)) => HasLoggingServer (config :: k1) (Verb mt st ct a :: Type) ctx

Defined in Servant.Util.Combinators.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (Verb mt st ct a)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (Verb mt st ct a))) -> Router env

HasLoggingServer config subApi ctx => HasLoggingServer (config :: Type) (TagDescriptions ver mapping :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.Tag

Methods

routeWithLog :: Proxy (LoggingApiRec config (TagDescriptions ver mapping :> subApi)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (TagDescriptions ver mapping :> subApi))) -> Router env

HasLoggingServer config subApi ctx => HasLoggingServer (config :: Type) (Tag name :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.Tag

Methods

routeWithLog :: Proxy (LoggingApiRec config (Tag name :> subApi)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (Tag name :> subApi))) -> Router env

(HasLoggingServer config subApi ctx, HasContextEntry (ctx .++ DefaultErrorFormatters) ErrorFormatters, ReifySortingItems base, ReifyParamsNames provided) => HasLoggingServer (config :: Type) (SortingParams provided base :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.Sorting.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (SortingParams provided base :> subApi)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (SortingParams provided base :> subApi))) -> Router env

(HasLoggingServer config subApi ctx, AreFilteringParams params, ReifyParamsNames params, BuildSomeFilter params) => HasLoggingServer (config :: Type) (FilteringParams params :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.Filtering.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config (FilteringParams params :> subApi)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (FilteringParams params :> subApi))) -> Router env

HasLoggingServer config subApi ctx => HasLoggingServer (config :: Type) (ErrorResponses errors :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.ErrorResponses

Methods

routeWithLog :: Proxy (LoggingApiRec config (ErrorResponses errors :> subApi)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (ErrorResponses errors :> subApi))) -> Router env

(HasLoggingServer config subApi ctx, KnownPaginationPageSize settings, HasContextEntry (ctx .++ DefaultErrorFormatters) ErrorFormatters) => HasLoggingServer (config :: Type) (PaginationParams settings :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.Pagination

Methods

routeWithLog :: Proxy (LoggingApiRec config (PaginationParams settings :> subApi)) -> Context ctx -> Delayed env (Server (LoggingApiRec config (PaginationParams settings :> subApi))) -> Router env

newtype ServantLogConfig

Constructors

ServantLogConfig

Fields

• clcLog :: Text -> IO ()

newtype ForResponseLog a

When it comes to logging responses, returned data may be very large. Log space is valuable (already in testnet we got truncated logs), so we have to care about printing only whose data which may be useful.

Constructors

ForResponseLog

Fields

• unForResponseLog :: a

Instances

Buildable (ForResponseLog Integer)

Defined in Servant.Util.Combinators.Logging

Methods

build :: ForResponseLog Integer -> Builder

Buildable (ForResponseLog ())

Defined in Servant.Util.Combinators.Logging

Methods

build :: ForResponseLog () -> Builder

Buildable (ForResponseLog NoContent)

Defined in Servant.Util.Combinators.Logging

Methods

build :: ForResponseLog NoContent -> Builder

Buildable (ForResponseLog Swagger)

Defined in Servant.Util.Combinators.Logging

Methods

build :: ForResponseLog Swagger -> Builder

Buildable (ForResponseLog (SwaggerUiHtml dir api))

Defined in Servant.Util.Combinators.Logging

Methods

build :: ForResponseLog (SwaggerUiHtml dir api) -> Builder

buildListForResponse :: Buildable (ForResponseLog x) => (forall a. [a] -> [a]) -> ForResponseLog [x] -> Builder

buildForResponse :: Buildable a => ForResponseLog a -> Builder

class ApiHasArgClass api where

Proves info about argument specifier of servant API.

Minimal complete definition

Nothing

Associated Types

type ApiArg api :: Type

For arguments-specifiers of API, get argument type. E.g. Capture "cap" Int -> Int.

type ApiArg api = ApplicationRS api

Methods

apiArgName :: Proxy api -> String

Name of argument. E.g. name of argument specified by Capture "nyan" is nyan.

default apiArgName :: forall n someApiType a. (KnownSymbol n, api ~ someApiType n a) => Proxy api -> String

Instances

KnownSymbol s => ApiHasArgClass (QueryFlag s)

Defined in Servant.Util.Common.Common

Associated Types

type ApiArg (QueryFlag s)

Methods

apiArgName :: Proxy (QueryFlag s) -> String

ApiHasArgClass (ReqBody ct a)

Defined in Servant.Util.Common.Common

Associated Types

type ApiArg (ReqBody ct a)

Methods

apiArgName :: Proxy (ReqBody ct a) -> String

KnownSymbol s => ApiHasArgClass (Capture s a)

Defined in Servant.Util.Common.Common

Associated Types

type ApiArg (Capture s a)

Methods

apiArgName :: Proxy (Capture s a) -> String

KnownSymbol s => ApiHasArgClass (QueryParam' mods s a)

Defined in Servant.Util.Common.Common

Associated Types

type ApiArg (QueryParam' mods s a)

Methods

apiArgName :: Proxy (QueryParam' mods s a) -> String

class ApiHasArgClass subApi => ApiCanLogArg subApi where

Describes a way to log a single parameter.

Minimal complete definition

Nothing

Associated Types

type ApiArgToLog subApi :: Type

type ApiArgToLog subApi = ApiArg subApi

Methods

toLogParamInfo :: Buildable (ApiArgToLog subApi) => Proxy subApi -> ApiArg subApi -> Text

default toLogParamInfo :: Buildable (ApiArg subApi) => Proxy subApi -> ApiArg subApi -> Text

Instances

KnownSymbol cs => ApiCanLogArg (QueryFlag cs)

Defined in Servant.Util.Combinators.Logging

Associated Types

type ApiArgToLog (QueryFlag cs)

Methods

toLogParamInfo :: Proxy (QueryFlag cs) -> ApiArg (QueryFlag cs) -> Text

ApiCanLogArg (ReqBody ct a)

Defined in Servant.Util.Combinators.Logging

Associated Types

type ApiArgToLog (ReqBody ct a)

Methods

toLogParamInfo :: Proxy (ReqBody ct a) -> ApiArg (ReqBody ct a) -> Text

KnownSymbol s => ApiCanLogArg (Capture s a)

Defined in Servant.Util.Combinators.Logging

Associated Types

type ApiArgToLog (Capture s a)

Methods

toLogParamInfo :: Proxy (Capture s a) -> ApiArg (Capture s a) -> Text

(Buildable a, KnownSymbol cs, SBoolI (FoldRequired mods)) => ApiCanLogArg (QueryParam' mods cs a)

Defined in Servant.Util.Combinators.Logging

Associated Types

type ApiArgToLog (QueryParam' mods cs a)

Methods

toLogParamInfo :: Proxy (QueryParam' mods cs a) -> ApiArg (QueryParam' mods cs a) -> Text

addParamLogInfo :: Text -> ApiParamsLogInfo -> ApiParamsLogInfo

setInPrefix :: ApiParamsLogInfo -> ApiParamsLogInfo

serverWithLogging :: forall api a. ServantLogConfig -> Proxy api -> (forall (config :: Type). Reifies config ServantLogConfig => Proxy (LoggingApi config api) -> a) -> a

Apply logging to the given server.