hexLog

hexlog

HEXLOG contém sistema de madeira inspirado por log4j escrito em Haxe

Encontre mais informações sobre Hexmachina em hexmachina.org

Arquitetura

Componentes principais

As aplicações usando a API HEXLOG solicitarão um madeireiro com um nome específico do LogManager. O LogManager localizará o LoggerContext apropriado e, em seguida, obterá o logger dele. Se o madeireiro for criado, ele estará associado ao LoggerConfig que contém: a) o mesmo nome que o logger, b) o nome de um pacote pai ou c) o root loggerconfig. Os objetos LoggerConfig são criados a partir de declarações de logger na configuração. O LoggerConfig está associado aos LogTargets que realmente entregam os LogEvents.

Hierarquia de Logger

A maior vantagem de usar o hexlog por trace padrão é a capacidade de desativar certas instruções de log, permitindo que outras sejam impressas sem nenhuma alteração. Esse recurso pressupõe que o espaço de madeira, ou seja, o espaço de todas as instruções de registro possíveis, seja categorizado de acordo com alguns critérios escolhidos pelo desenvolvedor. Loggers e LoggerConfigs são nomeados entidades. Os nomes de logger são sensíveis ao maiúsculas e seguem a regra de nomeação hierárquica.

Hierarquia de nomeação

Diz -se que um LoggerConfig é um ancestral de outro LoggerConfig se seu nome seguido por um ponto ( . ) For um prefixo de um nome de descendente de madeireiro. Diz -se que um LoggerConfig é pai de um filho LoggerConfig se não houver ancestrais entre si e o descendente LoggerConfig.

Por exemplo, o LoggerConfig chamado "com.foo" é um pai do LoggerConfig chamado "com.foo.Bar" . Da mesma forma, "hex" é um pai de "hex.log" e um ancestral de "hex.log.Logger" . Esse esquema de nomenclatura deve ser familiar para a maioria dos desenvolvedores. O Root LoggerConfig reside no topo da hierarquia. É excepcional, pois sempre existe e faz parte de toda hierarquia. Um madeireiro diretamente vinculado ao Roo LoggerConfig pode ser obtido da seguinte forma:

 var rootLogger = LogManager . getLogger ( " " );
// or more simply
var rootLogger = LogManager . getRootLogger ();

Todos os outros madeireiros podem ser recuperados usando o método estático Logmanager.getLogger passando o nome do logger desejado.

LoggerContext

O LoggerContext atua como o ponto de ancoragem do sistema de registro. Atualmente, não é possível ter vários LoggerContexts, mas você pode alterar a implementação do LoggerContext alterando o valor de um imóvel estático LogManager.context .

Caso você queira usar o log no contexto macro, você pode usar MacroLoggerContext já preparado, que possui fábrica de mensagens pré -configurada e mensagens projetadas especificamente para imprimir expressões.

Configuração

O LoggerContext possui uma Configuration ativa. A configuração contém todos os LogTargets, filtros em todo o contexto e LoggerConfigs.

Logger

Como afirmado anteriormente, o Logger pode ser criado chamando LogManager.getLogger . O próprio Logger não executa ações diretas. Ele simplesmente tem um nome e está associado a um LoggerConfig. Ele estende a abstrataLogger e implementa os métodos necessários. Como a configuração é modificada, os loggers podem se associar a um LoggerConfig diferente, fazendo com que seu comportamento seja modificado.

Recuperação de madeireiros

Chamar o método LogManage.getLogger com o mesmo nome sempre retornará uma referência ao mesmo objeto Logger. Isso significa:

 var x = LogManager . getLogger ( " something " );
var y = LogManager . getLogger ( " something " );

x e y consultem exatamente o mesmo objeto Logger. ( x == y é sempre true )

A configuração do ambiente de hexlog é sempre feita na inicialização do aplicativo.

O hexlog facilita a nomeação do componente de madeireiros por software . Isso pode ser realizado instanciando o Logger em cada classe, com o nome do Logger igual ao nome totalmente qualificado da classe. Este é um método útil e direto para definir madeireiros. À medida que a saída do log carrega o nome do logger gerador, essa estratégia de nomenclatura facilita a identificação da origem da mensagem de log. No entanto, essa é apenas uma estratégia possível de nomear madeireiros e hexlog não restringe o possível conjunto de madeireiros. O desenvolvedor é sempre livre para nomear os madeireiros conforme desejado.

Por conveniência, o hexlog fornece um conjunto de funções que você pode importar para gerar chamadas getLogger automaticamente. É especialmente útil ao usar o arquivo import.hx . (Veja o exemplo)

Métodos de conveniência adicionais são getLoggerByClass e getLoggerByInstance , que são úteis no contexto macro, onde você não pode usar a classe de conveniência do hexlog.

LoggerConfig

Os objetos LoggerConfig são criados quando os loggers são declarados na configuração de log. O LoggerConfig contém um conjunto de filtros que devem permitir que o LogEvent seja aprovado antes de ser transmitido para qualquer algetes. Ele também contém referência ao conjunto de LogTargets que devem ser usados ​​para processar o evento.

Filtro

Além do hexlog de filtragem de nível de log automático, fornece filtros que podem ser aplicados:

• antes do controle ser passado para qualquer loggerconfig
• Depois que o controle é passado para um LoggerConfig, mas antes de ligar para qualquer LogTargets
• Depois que o controle é passado para um LoggerConfig, mas antes de chamar um LogTarget específico
• em cada logtarget

Mais informações sobre filtros e filtragem

Logtarget

A capacidade de ativar ou desativar seletivamente as solicitações de registro com base em seu madeireiro é apenas parte da imagem. O hexlog permite que as solicitações de registro sejam impressas em vários destinos. No Hexlog Speak, um destino de saída é chamado LogTarget.

Mais informações sobre metas de log

Layout

Na maioria das vezes, os usuários desejam personalizar não apenas o destino de saída, mas também o formato de saída. Isso é realizado associando um layout a um LogTarget. O layout é responsável pela formatação do LogEvent para os desejos do usuário, enquanto um destino de log cuida do envio da saída formatada ao seu destino.

Mais informações sobre layouts

Mensagem

Internamente no sistema, todas as instruções de log é representada por um objeto de mensagem.

Mais informações sobre mensagens

Exemplos simples

Log

 // Getting logger
var logger = LogManager . getLogger ( " LoggerName " );

// Logging simple message
logger . debug ( " Some message " );

// Logging message with parameters
var name = " World " ;
logger . debug ( " Hello {} " , [ name ]);

Usando a classe HexLog de conveniência

Se você está planejando registrar extensivamente, é uma boa prática primeiro obter looger para sua aula e depois usá -la para enviar suas mensagens

 import hex . log . HexLog . * ; // Import all convenience functions

// If you're planning to use logger extensively, first get logger for your class
var logger = getLogger ();
// Gets replaced with:
// var logger = hex.log.LogManager.getLogger("my.current.class");
logger . debug ( " Hello world! " ); // you can now use logger as usual

Se você só precisar de uma declaração de depuração simples e não está preocupada com o desempenho, pode usar funções ainda mais abstratas.

 import hex . log . HexLog . * ; // Import all convenience functions

debug ( " Hello world " );
info ( " Hello world " );
warn ( " Hello world " );
error ( " Hello world " );
fatal ( " Hello world " );

// Gets replaced with:
// hex.log.LogManager.getLogger("my.current.class").debug("Hello world");
// ... etc 

Configuração

 // -- You can see this working in hex.log.ConfigurationTest.hx

// Create a new configuration
var configuration = new BasicConfiguration ();

// Create log targets
var traceTarget = new TraceLogTarget ( " Trace " , null , new DefaultTraceLogLayout ());

// Create a logger config and add targets
// (at this point we can also add filters to the configuration etc.)
var lc1 : LoggerConfig = LoggerConfig . createLogger ( " hex " , LogLevel . WARN , null , null ); // Logger will only forward warnings and higher
lc1 . addLogTarget ( traceTarget , LogLevel . ALL , null ); // Target will accept every event that arrives (in this case only warnings+ will be forwarded from the logger anyway)
configuration . addLogger ( lc1 . name , lc1 ); // Add logger config to the configuration

// Apply the configuration
LoggerContext . getContext (). setConfiguration ( configuration );

// Now you can request loggers and log as much you want and they will follow the rules set above
var logger = LogManager . getLogger ( " hex " );
logger . debug ( " test " ); // Fitered by config -> nothing will happen
logger . warn ( " test " ); // will be logged

var logger2 = LogManager . getLogger ( " hex.log " );
logger2 . debug ( " test " ); // Fitered by parent config -> nothing will happen
logger2 . warn ( " test " ); // will be logged

// NOTE: By default root logger is set to LogLevel.ERROR
var logger3 = LogManager . getLogger ( " something " );
logger3 . debug ( " test " ); // Filtered by root logger -> nothing will happen
logger3 . error ( " test " ); // will be logged