Melhor maneira de log do que chamadas manuais para uma função de registro?

5

Estou escrevendo um servidor web simples em Haskell e colocando um pouco de log. Eu tenho algumas chamadas para uma função de registro em uma cadeia de IO >>= . Tudo parece um pouco manual. Existe uma maneira melhor / mais "Haskelish"?

log :: (Show a) => String -> a -> IO a
log label val = getCurrentTime >>= \time ->
                putStrLn ("[" ++ show time ++ "] [" ++ label ++ "] " ++ (take maxLogLength $ show val)) >>
                return val 

handle :: Socket -> IO ()
handle conn = recv conn incomingBufferSize >>=
              log "request" >>=
              log "path" . extractPath . unpack >>=
              response >>= log "response" >>=
              send conn >>
              close conn
    
por Michal Charemza 11.03.2017 / 15:25
fonte

3 respostas

1

A Programação Orientada a Aspectos é a abordagem usual para isso. Em java, você intercepta os métodos que deseja registrar. Para o desenvolvedor, parece que nada está acontecendo, mas toda vez que esse método é chamado, ele é registrado automaticamente.

Não tenho certeza se o idioma que você está usando é compatível com AOP, mas tenho certeza de que pode haver alguma maneira de implementar um sistema semelhante.

    
por 11.05.2017 / 11:52
fonte
1

O registro em log é um caso de uso comum usado durante a apresentação do chamado Free monads , Freer monads e / ou Efeitos Extensíveis .

Em qualquer caso, a idéia básica é simples - em vez de fazer com que seu programa execute ações diretamente, seu programa produz uma estrutura de dados que descreve abstratamente as ações a serem executadas. A execução real dessas ações é adiada para um intérprete que interpreta a estrutura de dados.

Existem pelo menos duas maneiras pelas quais isso pode ser aplicado ao registro. O primeiro é especificando algum conjunto de operações explícitas de registro. Isso não é muito diferente do que você possui atualmente, exceto que a implementação das operações de log pode ser alterada, fornecendo um interpretador diferente. Por exemplo, você pode alterar para onde o log vai ou até mesmo eliminar o registro em log todos juntos (ou seja, implementar o log como um não operacional).

Outra maneira de aplicar isso é adicionar log à interpretação de certas operações. Se feito corretamente, o registro e a interpretação "real" da operação são completamente ortogonais. Isso é análogo à programação orientada a aspectos, que permite que códigos adicionais sejam "misturados" ao código principal.

    
por 21.08.2017 / 22:38
fonte
0

Em vários idiomas, você pode implementar funções de log como decoradores. Isso pode valer a pena investigar, mas no processo me deparei com o pacote hslogger (documentation ).

    
por 12.03.2017 / 09:23
fonte