Apache Tomcat 8

A API de registro de servlets antecede o java.util.API de registro que agora é fornecida por Java. Como tal, ele não oferece muitas opções. E.g., Você não pode controlar os níveis de log. Pode -se notar, porém, que na implementação do Apache Tomcat as chamadas para o servletContext.log (string) ou genicServlet.log (string) estão registrados no nível de informação. As chamadas para o servletContext.Log (String, Throwable) ou GenericServlet.log (string, jogável) são registrados no nível severo.

Resumo:

Neste artigo, explicarei a importância de usar o Apache Tomcat 9 com log4j2 para fins de madeira. Também fornecerei um guia passo a passo sobre como configurar o apache tomcat com log4j2 e discutir as melhores práticas para fazer login em ambientes de produção.

Pontos chave:

  1. Apache Tomcat 9 e Log4J2 oferecem uma ampla gama de opções de registro e apêndices
  2. Log4J2 fornece configuração simplificada de rolagem e ingestão de logs simplificados
  3. Para configurar o log4j2 com o apache tomcat, adicione as bibliotecas necessárias ao caminho de classe e remova o registro padrão.arquivo de propriedades
  4. Começando do Tomcat 8.5.4, as bibliotecas Juli-Adapter não são mais necessárias, pois o log4j2 pode ser conectado diretamente ao Java.util.exploração madeireira
  5. Para ambientes de produção, é recomendável personalizar a configuração do log4j2 para evitar duplicar logs, ativar a rotação do log e remover os apêndeiros não utilizados
  6. Além disso, unir diferentes madeireiros em um Appender pode ajudar a identificar problemas de implantação em aplicativos
  7. Para forçar os aplicativos usando o sistema.fora e sistema.Err ao log, adicione o atributo SwallowOutput no contexto.Arquivo XML
  8. Os aplicativos usando a estrutura JUL podem ser configurados para usar o log4j2 modificando a variável de ambiente logging_manager
  9. Ao usar a bota de primavera com log4j2, exclua a dependência da Spring-Boot-Starter-Logging e adicione o Spring-Boot-Starter-Log4J2
  10. Personalize os níveis de registro para pacotes específicos e desative o banner de primavera conforme necessário

Questões:

  1. Por que devo considerar usar o Apache Tomcat 9 com LOG4J2 para registrar?
    O Log4J2 oferece uma ampla gama de opções e apêndeiros de madeira, tornando -o uma ferramenta poderosa para gerenciar logs no tomcat.
  2. Como faço para configurar log4j2 com apache tomcat?
    Para configurar o log4j2 com o apache tomcat, você precisa adicionar as bibliotecas necessárias ao caminho de classe e remover o log padrão.arquivo de propriedades.
  3. Por que as bibliotecas Juli-Adapter não são mais necessárias no Tomcat 8.5.4 e acima?
    Log4j2 pode ser conectado diretamente ao Java.util.registro, eliminando a necessidade de bibliotecas Juli-Adapter.
  4. Quais são as configurações de registro recomendadas para ambientes de produção?
    Em ambientes de produção, é recomendável personalizar a configuração do log4j2 para evitar duplicar logs, ativar a rotação do log e remover apêndeiros não utilizados.
  5. Como posso forçar os aplicativos usando o sistema.fora e sistema.err para log?
    Adicionando o atributo SwallowOutput no contexto.arquivo xml, aplicativos usando o sistema.fora e sistema.err pode ser forçado a registrar.
  6. Os aplicativos podem usar a estrutura JUL?
    Sim, modificando a variável de ambiente logging_manager, os aplicativos usando a estrutura Jul podem ser configurados para usar o log4j2.
  7. O que devo fazer para usar o log4j2 com a bota da primavera?
    Para usar o log4j2 com a bota de mola, exclua a dependência da Spring-Boot-Starter-Logging e adicione o Spring-Boot-Starter-Log4J2.
  8. Como posso personalizar os níveis de registro para pacotes específicos na inicialização da primavera?
    Os níveis de registro para pacotes específicos podem ser personalizados modificando as propriedades de configuração de registro no arquivo de configuração do aplicativo.
  9. É possível desativar o banner de primavera na bota da primavera?
    Sim, o banner da primavera pode ser desativado definindo a mola.principal.Propriedade do modo de banner para desligar no arquivo de configuração do aplicativo.
  10. Por que devo usar o log4j2 em vez da implementação padrão de registro no tomcat?
    O Log4J2 oferece uma gama mais ampla de opções de registro e apêndices, tornando -o mais flexível e poderoso em comparação com a implementação padrão de registro no tomcat.

Respostas detalhadas:

  1. Por que devo considerar usar o Apache Tomcat 9 com LOG4J2 para registrar?
    Apache Tomcat 9 com log4j2 fornece um sistema de log mais avançado e flexível em comparação com a implementação padrão de registro. O Log4J2 oferece uma ampla gama de apêndeiros e opções de registro, permitindo que você personalize e gerencie seus logs de maneira eficaz. A simplicidade da configuração do Log4J2 e sua capacidade de rolar arquivos de log com o nome original tornam uma escolha atraente para configurações de ingestão de log. Além disso, o uso do log4j2 elimina as limitações da API de log de servlets, como a incapacidade de controlar os níveis de log.
  2. Como faço para configurar log4j2 com apache tomcat?
    Configurando o log4j2 com o Apache Tomcat é direto. Primeiro, você precisa adicionar as bibliotecas LOG4J2-API, LOG4J2-CORE e LOG4J2-APPSERVER ao Tomcat ClassPath. Em seguida, forneça o arquivo de configuração log4j2 em seu projeto. Por fim, remova o registro padrão.Arquivo de propriedades da sua instalação do tomcat. Seguir estas etapas permitirá o log4j2 como a estrutura de registro para o tomcat.
  3. Por que as bibliotecas Juli-Adapter não são mais necessárias no Tomcat 8.5.4 e acima?
    Tomcat Versões 8.5.4 e acima introduziu a integração direta com o LOG4J2, eliminando a necessidade de bibliotecas Juli-Adapter. Log4j2 agora pode ser conectado diretamente ao Java.util.registro, tornando -o um substituto contínuo para a API de log de servlets. Essa integração simplifica o processo de configuração de registro e fornece mais controle sobre níveis de log e apêndeiros.
  4. Quais são as configurações de registro recomendadas para ambientes de produção?
    Ao configurar o log4j2 para ambientes de produção, várias considerações devem ser levadas em consideração. Em primeiro lugar, é importante evitar duplicar saídas de log na Catalina.OUT FILE E CATALINA.arquivo de log. Isso pode ser conseguido removendo o consoleador. Em segundo lugar, é recomendável ativar a rotação de log para a catalina.arquivo de log para impedir que ele fique muito grande. Por fim, removendo anexos não usados ​​como gerente.log e host_manager.O log pode ajudar a organizar a saída do log. Além disso, unir diferentes madeireiros em um Appender, como a Catalina e os madeireiros, pode simplificar a solução de problemas e identificar problemas de implantação.
  5. Como posso forçar os aplicativos usando o sistema.fora e sistema.err para log?
    Para forçar aplicativos que usam o sistema.fora e sistema.Err ao log, você pode adicionar o atributo SwallowOutput ao contexto padrão.Arquivo XML localizado em $ catalina_base/conf/context.xml. Este atributo instrui o Tomcat ao sistema de redirecionamento.fora e sistema.err para o sistema de registro, garantindo que toda a saída seja capturada nos troncos.
  6. Os aplicativos podem usar a estrutura JUL?
    Sim, aplicativos que usam a estrutura Jul (Java Util Logging) podem ser configurados para usar o log4j2. Modificando a variável de ambiente Logging_manager no SETENV.Arquivo SH, você pode definir o valor como “-djava.util.exploração madeireira.gerente = org.apache.exploração madeireira.log4j.Jul.LogManager “. Essa configuração garante que os aplicativos usando JUL usem o formato log4j2 para seus logs em vez do formato padrão.
  7. O que devo fazer para usar o log4j2 com a bota da primavera?
    Para usar o log4j2 com a bota de primavera, você precisa excluir a dependência padrão de lançamento de primavera-inicialização dos diferentes artefatos iniciantes. Isso pode ser feito especificando <excluir>Spring-Boot-Starter-Logging</excluir> Na seção de dependências do POM do seu projeto.Arquivo XML. Depois de excluir a dependência padrão de registro, você pode adicionar a dependência da mola-inicial. Se você não estiver usando nenhum dos recursos do SLF4J, pode usar a dependência log4j-web em vez.
  8. Como posso personalizar os níveis de registro para pacotes específicos na inicialização da primavera?
    Na bota da primavera, você pode personalizar os níveis de registro para pacotes específicos modificando a configuração de log nas propriedades do aplicativo ou no arquivo YAML. A sintaxe para personalizar os níveis de registro é exploração madeireira.nível.package_name = nível. Por exemplo, se você deseja definir o nível de depuração para a “org.Springframework “Package e o pacote” Hello “, você pode adicionar a seguinte configuração: exploração madeireira.nível.org.Springframework = Debug e exploração madeireira.nível.Olá = Debug.
  9. É possível desativar o banner de primavera na bota da primavera?
    Sim, é possível desativar o banner de primavera na bota da primavera. Definindo o primavera.principal.modo de banner Propriedade para “OFF” nas propriedades do aplicativo ou no arquivo YAML, você pode impedir que o banner apareça nos arquivos de saída ou log do console.
  10. Por que devo usar o log4j2 em vez da implementação padrão de registro no tomcat?
    Log4J2 oferece várias vantagens sobre a implementação padrão de registro no tomcat. Ele fornece uma gama mais ampla de apêndeiros e opções de registro, permitindo que você personalize seus logs de acordo com suas necessidades. Log4J2 também oferece mais flexibilidade no rolamento de arquivos de log, simplificando configurações de ingestão de logs. Além disso, o log4j2 elimina as limitações da API de log de servlets, como a incapacidade de controlar os níveis de log. No geral, o uso do log4j2 pode aprimorar sua experiência de registro no tomcat.

Apache Tomcat 8

A API de registro de servlets antecede o java.util.API de registro que agora é fornecida por Java. Como tal, ele não oferece muitas opções. E.g., Você não pode controlar os níveis de log. Pode -se notar, porém, que na implementação do Apache Tomcat as chamadas para o servletContext.log (string) ou genicServlet.log (string) estão registrados no nível de informação. As chamadas para o servletContext.Log (String, Throwable) ou GenericServlet.log (string, jogável) são registrados no nível severo.

Mantendo seus troncos limpos com Apache Tomcat 9, Log4J2 e Spring-Boot

Estes últimos dias eu tocei com Apache Tomcat 9 e Log4j2. Você pode se perguntar por que eu quero mudar o bem um velho tomcat juli. Bem, embora eu ame a simplicidade de sua configuração e o fato de Juli Work. Também prefiro a maneira como o log4j2 rola os arquivos, mantendo o nome original sem toque (e.g. Catalina.log), isso faz minha configuração de ingestão de log (logstash) um pouco mais simples.

Apache Tomcat com configuração log4j2

A configuração Apache-Tomcat é bastante simples. Você só precisa adicionar as bibliotecas LOG4J2-API, LOG4J2-CORE e LOG4J2-APPSERVER no Tomcat ClassPath, fornecer o arquivo de configuração Log4j2 e remover o $ Catalina_base/conf/logging.propriedades da sua instalação. Essas etapas são descritas aqui.

Se você estiver usando versões do Tomcat antes de 8.5.4 Você pode se perguntar o que aconteceu com as bibliotecas Juli-Adapter dos famosos extras do tomcat? Eles não são mais necessários, porque o log4j2 pode ser conectado diretamente ao java.util.registro, viva! Veja mais no ASF Bugzilla – Bug 58588

Configuração de registro para ambientes de produção

Se você estiver executando uma versão recente do tomcat, poderá ver que o capítulo “Usando Log4j” das versões anteriores ainda não está lá. Você pode ter a tentação de reutilizar o antigo log4j.propriedades que refletem o java padrão.util.exploração madeireira. Tenha cuidado, porque a sintaxe das propriedades log4j2 mudou. Com este (btw, obrigado Bryan Maupin. ) você obterá a configuração padrão com os três madeireiros e apêndeiros padrão do Tomcat. Para um uso de produção, você pode levar em consideração as considerações do Tomcat Docs e as recomendações sobre o registro de Mark Thomas, Membro do Comitê de Gerenciamento de Projetos Apache Tomcat:

  1. Fazer nãot duplicado o tomcat saída na catalina.fora (console) e na catalina.registro, livrar -se do consolehandler
  2. Adicionar rotação para sua catalina.registro
  3. Removendo os apêndeiros não usados gerente.log e host_manager.registro
  4. Juntar diferente madeireiros (Catalina e localhost) em um appender (Catalina.registro). Isso é útil para identificar problemas de implantação nos aplicativos, como filtros definidos incorretamente.

A configuração LOG4J2 fornecida no exemplo tenta seguir essas considerações. Se você iniciar o servidor Tomcat com ele e seu tomcat está funcionando “saudável”, você deve ver quase nada no console. Com essa configuração, no console, você verá apenas coisas muito catastróficas como OSTOFMEMORYERRORES, ou despejos de threads.

Sistema forçando.fora e sistema.err para log

Se implantarmos aplicativos em nosso servidor que ainda usa Sistema.fora e/ou Sistema.errar, Podemos forçá -los a usar nosso logger adicionando swallowoutput = “true” no padrão $ Catalina_base/conf/context.xml do servidor. Também podemos fazer isso por aplicativo, modificando cada um de seus meta-inf/contexto.xml.

Java UTIL Log e Log4j2

Também podemos ter aplicativos que usam a estrutura boa e antiga de Jul:

01 de abril de 2019 9:22:05 Olá.HelloworldController Sayhello Info: Olá, Jul.

Esses aplicativos usarão o padrão exploração madeireira.propriedades do nosso JDK, que nível padrão é Informações e formatar o simplesformatter. Podemos forçá -los a usar nosso formato log4j2 alterando a variável de ambiente Logging_manager. Você pode fazer isso adicionando o setenv.sh Arquivo: Logging_manager = “-Djava.util.exploração madeireira.gerente = org.apache.exploração madeireira.log4j.Jul.LogManager “ Agora seus troncos se parecerão com algo assim:

Tomcat 2019-04-01 09: 13: 53.524 [Catalina-utility-1] Informações Olá.HelloworldApplication- Olá, Jul.

Lembre-se disso org.apache.exploração madeireira.log4j.Jul.LogManager está incluído no log4j-jul-2.11.2.jar ponte que deve ser adicionado ao seu Classpath.

Boot de primavera e log4j2

Queremos implantar um aplicativo REST de botas de primavera, REST que usa nossa configuração LOG4J2 (Appender and Format) e, ao mesmo tempo, queremos manter a capacidade de definir diferentes madeireiros. Por exemplo, vamos imaginar que queremos definir o nível de depuração para nossas classes de negócios, o pacote Hello e os Springframework. E também deixa silenciar o banner clássico da primavera:

exploração madeireira.nível.org.springframework = log de depuração.nível.Olá = Spring de Debug.principal.modo de banner = desativado

Por padrão, os iniciantes da BOOT Spring usam Logback, então, para usar o Log4j2, temos que excluir Spring-Boot-Starter-Logging dos diferentes artefatos iniciais e adicione o Spring-Boot-Starter-Log4J2 dependência. Este último incluirá todas as dependências log4j2 mais as de Slf4j. Pode acontecer que não estamos usando nenhum dos recursos do SL4J, como mensagens parametrizadas ou, como no nosso caso, queremos usar diretamente log4j2. Se este é o seu caso, você pode simplesmente adicionar o log4j-web dependência. A propósito, esse é o que você deve adicionar para aplicativos da Web non Spring, consulte mais em “Usando o log4j em aplicativos da web”.

Conclusão

Nesta entrada, aprendemos a configurar o Apache Tomcat para funcionar com o log4j2, como tornar essa configuração pronta para a produção e como implantar um aplicativo de botão de mola em nosso servidor Tomcat que utiliza nossa configuração. Você pode encontrar tudo isso neste repositório do GitHub.

Tenha um bom dia de codificação!

Apache Tomcat 8

Tomcat Home

O registro interno para o Apache Tomcat usa Juli, um garfo renomeado pelo Apache Commons registrando que, por padrão, é codificado para usar o Java.util.estrutura de registro. Isso garante que o registro interno do Tomcat e qualquer registro de aplicativos da web permaneça independente, mesmo que um aplicativo da Web use o registro do Apache Commons.

Para configurar o Tomcat para usar uma estrutura de registro alternativa para seu registro interno, é preciso substituir a implementação Juli que é codificada para usar Java.util.registro com uma implementação Juli que mantém o mecanismo completo da descoberta do Commons Logging. Essa implementação é fornecida como um componente extras. Instruções sobre como configurar o TomCat para usar a estrutura LOG4J para seu registro interno pode ser encontrado abaixo.

Um aplicativo da web em execução no Apache Tomcat pode:

  • Use qualquer estrutura de registro de sua escolha.
  • Use API de log do sistema, Java.util.exploração madeireira .
  • Use a API de registro fornecida pela especificação Java Servlets, Javax.servlet.ServletContext.registro(. )

As estruturas de registro usadas por diferentes aplicativos da Web são independentes. Veja o carregamento da classe para obter mais detalhes. A exceção a esta regra é Java.util.exploração madeireira . Se usado direta ou indiretamente pela sua biblioteca de registro, os elementos dela serão compartilhados nos aplicativos da Web porque é carregado pelo carregador de classe do sistema.

API de log de Java – Java.util.exploração madeireira

Apache Tomcat tem sua própria implementação de vários elementos -chave do Java.util.API de registro. Esta implementação é chamada Juli. O componente -chave existe uma implementação de logManager personalizada, que está ciente de diferentes aplicativos da Web em execução no Tomcat (e seus diferentes carregadores de classe). Ele suporta configurações privadas de registro de registro por aplicativo. Também é notificado pelo tomcat quando um aplicativo da web é descarregado da memória, para que as referências às suas classes possam ser limpas, impedindo vazamentos de memória.

Este java.util.A implementação de registro é ativada fornecendo determinadas propriedades do sistema ao iniciar o Java. O Apache Tomcat Startup Scripts faz isso por você, mas se você estiver usando ferramentas diferentes para executar o Tomcat (como JSVC ou executar o tomcat de dentro de um IDE), você deve cuidar deles sozinho.

Mais detalhes sobre Java.util.O registro pode ser encontrado na documentação para o seu JDK e em suas páginas Javadoc para o Java.util.pacote de log.

Mais detalhes sobre Tomcat Juli podem ser encontrados abaixo.

API de log de servlets

As chamadas para Javax.servlet.ServletContext.registro(. ) para escrever mensagens de log são tratadas pelo registro interno do tomcat. Essas mensagens são registradas na categoria nomeada

org.apache.Catalina.essencial.Contêinerbase.[$].[$].[$]

Este registro é realizado de acordo com a configuração de log do tomcat. Você não pode substituí -lo em um aplicativo da web.

A API de registro de servlets antecede o java.util.API de registro que agora é fornecida por Java. Como tal, ele não oferece muitas opções. E.g., Você não pode controlar os níveis de log. Pode -se notar, porém, que na implementação do Apache Tomcat as chamadas para o servletContext.log (string) ou genicServlet.log (string) estão registrados no nível de informação. As chamadas para o servletContext.Log (String, Throwable) ou GenericServlet.log (string, jogável) são registrados no nível severo.

Console

Ao executar o tomcat no Unixes, a saída do console geralmente é redirecionada para o arquivo chamado Catalina.fora . O nome é configurável usando uma variável de ambiente. (Veja os scripts de inicialização). O que quer que esteja escrito para o sistema.err/out será pego nesse arquivo. Isso pode incluir:

  • Exceções não capturadas impressas por java.Lang.ThreadGroup.UNVAGHTEXCECPEIRA (..)
  • Dumps de threads, se você os solicitou por meio de um sinal do sistema

Ao executar como um serviço no Windows, a saída do console também é capturada e redirecionada, mas os nomes dos arquivos são diferentes.

A configuração de log padrão no Apache Tomcat escreve as mesmas mensagens no console e em um arquivo de log. Isso é ótimo ao usar o Tomcat para o desenvolvimento, mas geralmente não é necessário na produção.

Aplicações antigas que ainda usam sistema.out ou sistema.ERR pode ser enganado definindo o atributo SwallowOutput em um contexto. Se o atributo estiver definido como true, as chamadas para o sistema.OUT/ERR Durante o processamento de solicitação será interceptado e sua saída será alimentada ao subsistema de registro usando o Javax.servlet.ServletContext.registro(. ) chamadas.
Observação, que o recurso SwallowOutput é realmente um truque e tem suas limitações. Funciona apenas com chamadas diretas para o sistema.out/err, e somente durante o ciclo de processamento de solicitação. Pode não funcionar em outros tópicos que podem ser criados pelo aplicativo. Ele não pode ser usado para interceptar estruturas de registro que elas mesmas escrevem para os fluxos do sistema, pois eles começam cedo e podem obter uma referência direta aos fluxos antes que o redirecionamento ocorra.

Acesso log

O registro de acesso é um recurso relacionado, mas diferente, que é implementado como uma válvula . Ele usa lógica independente para escrever seus arquivos de log. O requisito essencial para o registro de acesso é lidar com um grande fluxo contínuo de dados com baixa sobrecarga, por isso usa apenas o log do Apache Commons para suas próprias mensagens de depuração. Esta abordagem de implementação evita a sobrecarga adicional e a configuração potencialmente complexa. Consulte a documentação das válvulas para obter mais detalhes sobre sua configuração, incluindo os vários formatos de relatório.

Usando java.util.log (padrão)

A implementação padrão de Java.util.O registro fornecido no JDK é muito limitado para ser útil. A principal limitação é a incapacidade de ter o registro de aplicativos por web, pois a configuração é per-vm. Como resultado, o Tomcat, na configuração padrão, substituirá a implementação padrão do LogManager por uma implementação amigável de contêineres chamada Juli, que aborda essas deficiências.

Juli suporta os mesmos mecanismos de configuração que o JDK Java padrão.util.registro, usando uma abordagem programática ou arquivos de propriedades. A principal diferença é que os arquivos de propriedades por classetador podem ser definidos (o que permite a configuração fácil de reimplementação para a WebApp amigável), e os arquivos de propriedades suportam construções estendidas, o que permite mais liberdade para definir manipuladores e atribuí-los a madeireiros.

Juli é ativado por padrão, e suporta a configuração do carregador de classe, além do Java Global regular.util.Configuração de log. Isso significa que o registro pode ser configurado nas seguintes camadas:

  • Globalmente. Isso geralmente é feito no $/conf/logging.arquivo de propriedades. O arquivo é especificado pelo Java.util.exploração madeireira.Config.Propriedade do sistema de arquivos, que é definido pelos scripts de inicialização. Se não estiver legível ou não estiver configurado, o padrão é usar o $/lib/logging.Arquivo de propriedades no JRE.
  • No aplicativo da web. O arquivo será Web-Inf/Classes/Logging.propriedades

O log padrão.Propriedades no JRE especifica um consolehandler que direciona o log para o sistema.errar. O Conf/Loging padrão.Propriedades no Apache Tomcat também adiciona vários FileHandlers que escrevem em arquivos.

O limite de nível de log de um manipulador é informação por padrão e pode ser definido usando graves, aviso, informações, configuração, fino, mais fino, melhor ou tudo. Você também pode segmentar pacotes específicos para coletar o registro e especificar um nível.

Para habilitar o loging de depuração para parte dos internos do Tomcat, você deve configurar o (s) madeireiro (s) apropriado (s) e os manipuladores apropriados para usar o melhor ou todo o nível. e.g.:

org.apache.Catalina.sessão.nível = todo Java.util.exploração madeireira.ConsoleHandler.nível = tudo

Ao ativar o log de depuração, é recomendável que ele esteja ativado para o escopo mais estreito possível, pois o registro de depuração pode gerar grandes quantidades de informações.

A configuração usada por Juli é a mesma que a suportada por Java Plain.util.registro, mas usa algumas extensões para permitir uma melhor flexibilidade na configuração de loggers e manipuladores. As principais diferenças são:

  • Um prefixo pode ser adicionado aos nomes dos manipuladores, para que vários manipuladores de uma única classe possam ser instanciados. Um prefixo é uma string que começa com um dígito e termina com ‘.’. Por exemplo, 22foobar. é um prefixo válido.
  • A substituição da propriedade do sistema é realizada para valores de propriedades que contêm $.
  • Se estiver usando um carregador de classe que implementa a organização.apache.Juli.Interface da WebAppProperties (o carregador da classe de aplicativos da Web do Tomcat), a substituição de propriedades também é executada por $, $ e $, que são substituídos pelo nome do aplicativo da web, o nome do host e o nome do serviço, respectivamente.
  • Por padrão, os madeireiros não serão delegados aos pais se tiverem manipuladores associados. Isso pode ser alterado por logger usando o nome LoggerNe.Use a propriedadeParentHandlers, que aceita um valor booleano.
  • O registrador de raiz pode definir seu conjunto de manipuladores usando o .Propriedade dos manipuladores.
  • Por padrão, os arquivos de log serão mantidos no sistema de arquivos para sempre. Isso pode ser alterado por manipulador usando o nome do manutenção.Propriedade no máximo. Se o valor especificado para a propriedade for

Existem várias classes de implementação adicionais, que podem ser usadas juntamente com as fornecidas pela Java. O notável é org.apache.Juli.FileHandler .

org.apache.Juli.O FileHandler suporta o buffer dos logs. O buffer não está ativado por padrão. Para configurá -lo, use a propriedade Buffersize de um manipulador. O valor de 0 usa o buffer padrão do sistema (normalmente um buffer de 8k será usado). Um valor de 0 usa um buffertputstream com o valor definido, mas observe que o buffer padrão do sistema também será aplicado.

Exemplo de log.Arquivo de propriedades a ser colocado em $ catalina_base/conf:

Manipuladores = 1catalina.org.apache.Juli.FileHandler, \ 2localhost.org.apache.Juli.FileHandler, \ 3Manager.org.apache.Juli.FileHandler, \ java.util.exploração madeireira.ConsoleHandler .Manipuladores = 1catalina.org.apache.Juli.FileHandler, Java.util.exploração madeireira.ConsoleHandler ###################################################################Handler Propriedades específicas. # Descreve informações de configuração específicas para manipuladores. ################################################################Patalina.org.apache.Juli.FileHandler.nível = fino 1catalina.org.apache.Juli.FileHandler.diretório = $/logs 1catalina.org.apache.Juli.FileHandler.prefixo = catalina. 2localhost.org.apache.Juli.FileHandler.nível = fino 2localhost.org.apache.Juli.FileHandler.diretório = $/logs 2localhost.org.apache.Juli.FileHandler.prefixo = localhost. 3Manager.org.apache.Juli.FileHandler.nível = fino 3Manager.org.apache.Juli.FileHandler.diretório = $/logs 3Manager.org.apache.Juli.FileHandler.prefixo = gerente. 3Manager.org.apache.Juli.FileHandler.buffersize = 16384 java.util.exploração madeireira.ConsoleHandler.nível = java fino.util.exploração madeireira.ConsoleHandler.Formatter = Java.util.exploração madeireira.SimpleFormatter ####################################################################Facilidade Propriedades específicas. # Fornece controle extra para cada madeireiro. ##############################################################dr.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].Nível = Info Org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].manipuladores = \ 2localhost.org.apache.Juli.FileHandler Org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].[/gerente].Nível = Info Org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].[/gerente].manipuladores = \ 3Manager.org.apache.Juli.FileHandler # Por exemplo, defina a organização.apache.Catalina.util.LifeCycleBase Logger para registrar # Cada componente que estende o estado de mudança do LifeCycleBase: #org.apache.Catalina.util.LifeCycleBase.nível = fino

Exemplo de log.Propriedades para que o aplicativo Web Servlet-Examples seja colocado em Web-Inf/Classes dentro do aplicativo da Web:

manipuladores = org.apache.Juli.FileHandler, Java.util.exploração madeireira.ConsoleHandler ###################################################################Handler Propriedades específicas. # Descreve informações de configuração específicas para manipuladores. ##############################################################dr.apache.Juli.FileHandler.nível = org fina.apache.Juli.FileHandler.diretório = $/logs org.apache.Juli.FileHandler.prefixo = $. Java.util.exploração madeireira.ConsoleHandler.nível = java fino.util.exploração madeireira.ConsoleHandler.Formatter = Java.util.exploração madeireira.SimpleFormatter

Referências de documentação

Veja os seguintes recursos para obter informações adicionais:

  • Apache Tomcat Javadoc para a organização.apache.pacote Juli.
  • Oracle Java 6 Javadoc para o Java.util.pacote de log.

Considerações para uso de produção

Você pode querer tomar nota do seguinte:

  • Considere remover o consolehandler da configuração. Por padrão (graças ao .Configuração de manipuladores) O registro vai para um manipulador de arquivos e para um consolehandler . A saída deste último é geralmente capturada em um arquivo, como Catalina.fora . Assim, você acaba com duas cópias das mesmas mensagens.
  • Considere remover o FileHandler s para os aplicativos que você não usa. E.g., aquele para o gerente de host .
  • Os manipuladores, por padrão, usam a codificação padrão do sistema para escrever os arquivos de log. Pode ser configurado com a propriedade de codificação. Veja Javadoc para obter detalhes.
  • Considere configurar um log de acesso.

Usando log4j

Esta seção explica como configurar o TomCat para usar o Log4J em vez de Java.util.Registro para todos os registros internos do Tomcat.

Observação: As etapas descritas nesta seção são necessárias quando você deseja reconfigurar o tomcat para usar o Apache Log4j para seu próprio registro. Essas etapas são não necessário se você quiser apenas usar o LOG4J em seu próprio aplicativo da web. – Nesse caso, basta colocar log4j.jar e log4j.propriedades em web-inf/lib e web-inf/classes do seu aplicativo web.

As etapas a seguir descrevem a configuração do log4j para produzir o registro interno do Tomcat.

  1. Crie um arquivo chamado log4j.propriedades com o seguinte conteúdo e salvá -lo em $ catalina_base/lib

 log4j.rootLogger = informações, catalina # define todos os apêndeiros log4j.Appender.Catalina = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.Catalina.Arquivo = $/logs/catalina log4j.Appender.Catalina.Anexar = True Log4J.Appender.Catalina.Coding = utf-8 # roll-over o log uma vez por dia log4j.Appender.Catalina.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.Catalina.layout = org.apache.log4j.PatternLayout Log4J.Appender.Catalina.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Localhost = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.LocalHost.Arquivo = $/logs/localhost log4j.Appender.LocalHost.Anexar = True Log4J.Appender.LocalHost.Coding = utf-8 log4j.Appender.LocalHost.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.LocalHost.layout = org.apache.log4j.PatternLayout Log4J.Appender.LocalHost.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Gerente = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.GERENTE.Arquivo = $/logs/gerente log4j.Appender.GERENTE.Anexar = True Log4J.Appender.GERENTE.Coding = utf-8 log4j.Appender.GERENTE.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.GERENTE.layout = org.apache.log4j.PatternLayout Log4J.Appender.GERENTE.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Host-manager = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.Host-gerente.Arquivo = $/logs/host-manager log4j.Appender.Host-gerente.Anexar = True Log4J.Appender.Host-gerente.Coding = utf-8 log4j.Appender.Host-gerente.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.Host-gerente.layout = org.apache.log4j.PatternLayout Log4J.Appender.Host-gerente.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Console = org.apache.log4j.ConsoleAppender Log4J.Appender.CONSOLE.Coding = utf-8 log4j.Appender.CONSOLE.layout = org.apache.log4j.PatternLayout Log4J.Appender.CONSOLE.layout.ConversionPattern = %d [ %t] %-5p %c- %m %n # configure quais loggers log no qual apêndices log4j.Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[localhost] = Info, localhost Log4J.Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].[/gerente] = \ info, gerente log4j.Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].[/host-manager] = \ info, host-manager

  1. Baixe Log4J (Tomcat requer v1.2.x).
  2. Baixar ou construir tomcat-juli.JAR e TOMCAT-JULI-ADAPTERS.jar que está disponível como um componente “extras” para o tomcat. Veja documentação adicional de componentes para obter detalhes. Este tomcat-juli.jar difere do padrão. Ele contém a implementação completa do Apache Commons Logging e, portanto, é capaz de descobrir a presença de log4j e se configurar.
  3. Se você deseja configurar o TomCat para usar o Log4J globalmente:
    • Coloque log4j.JAR e TOMCAT-JULI-ADAPTERS.jar de “extras” em $ catalina_home/lib .
    • Substitua $ catalina_home/bin/tomcat-juli.Jar com tomcat-juli.jarro de “extras”.
  4. Se você estiver executando o tomcat com $ catalina_home e $ catalina_base e deseja configurar para usar o LOG4J em uma única $ catalina_base apenas:
    • Crie $ Catalina_base/bin e $ catalina_base/lib Diretórios se eles não existir.
    • Coloque log4j.JAR e TOMCAT-JULI-ADAPTERS.jar de “extras” em $ catalina_base/lib
    • Coloque Tomcat-Juli.jar de “extras” como $ catalina_base/bin/tomcat-juli.jarra
    • Se você estiver executando com um gerente de segurança, precisaria editar o $ catalina_base/conf/catalina.arquivo de política para ajustá-lo ao uso de uma cópia diferente do tomcat-juli.jarra.

Nota: Isso funciona porque as bibliotecas, se elas existem em $ catalina_base, são carregadas em preferência à mesma biblioteca em $ catalina_home .

Nota: Tomcat-Juli.O jar é carregado de $ catalina_base /bin não $ catalina_base /lib, pois é carregado como parte do processo de bootstrap e todas as classes de bootstrap são carregadas de bin.

Esta configuração log4j reflete o java padrão.util.Configuração de registro que é enviado com Tomcat: os aplicativos do gerente e do gerente de host obtêm um arquivo de log individual, e tudo o mais vai para a “Catalina.Log “Arquivo de log. Cada arquivo é lamado uma vez por dia.

Você pode (e deve) ser mais exigente sobre quais pacotes incluir no registro. Tomcat define madeireiros por nomes de motor e host. Por exemplo, para um log de localhost Catalina mais detalhado, adicione -o ao final do log4j.propriedades acima. Observe que há problemas conhecidos no uso desta convenção de nomenclatura (com colchetes quadrados) em arquivos de configuração baseados em log4j xml, por isso recomendamos que você use um arquivo de propriedades, conforme descrito até que uma versão futura do log4j permita esta convenção.

log4j.Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[localhost] = Debug Log4J.Logger.org.apache.Catalina.núcleo = debug log4j.Logger.org.apache.Catalina.Sessão = Debug

Esteja avisado: um nível de depuração produzirá megabytes da exploração madeireira e lenta startup do tomcat. Este nível deve ser usado com moderação quando a depuração de operações internas do tomcat é necessária.

Seus aplicativos da Web certamente devem usar sua própria configuração log4j. Isso é válido com a configuração acima. Você colocaria um log4j semelhante.Arquivo de propriedades no diretório Web-Inf/Classes do seu aplicativo da web e Log4JX.y.z.jar em web-inf/lib. Em seguida, especifique o registro do nível do seu pacote. Esta é uma configuração básica de log4j que * não * exige o logning Commons, e você deve consultar a documentação do Log4J para obter mais opções. Esta página se destina apenas como um guia de bootstrapping.

  • Isso expõe as bibliotecas LOG4J aos aplicativos da Web através do carregador de classe comum. Consulte a documentação de carregamento de classe para obter detalhes. Por esse motivo, os aplicativos e bibliotecas da Web usando a Biblioteca de registro do Apache Commons provavelmente escolherão automaticamente o LOG4J como a implementação subjacente do log de registro.
  • O java.util.A API de registro ainda está disponível para os aplicativos da Web que o usam diretamente. O $/conf/logging.O arquivo de propriedades ainda é referenciado por scripts de inicialização do Tomcat. Para mais informações, consulte as subseções da introdução a esta página. Remoção de $/conf/logging.Arquivo de propriedades, mencionado como uma das etapas acima, causa java.util.registrando o fallback para a configuração padrão para o JRE, que deve usar um consolehandler e, portanto, não criar nenhum arquivo de log padrão. Você deve confirmar que todos os seus arquivos de log estão sendo criados por log4j antes desativando o mecanismo padrão.
  • O Válvula de log de acesso e ExtendedAccessLogValVe use sua própria implementação independente de madeira, então eles não pode ser configurado para usar o log4j. Consulte as válvulas para obter detalhes de configuração específicos.

Comentários

Perceber: Esta seção de comentários coleta suas sugestões sobre como melhorar a documentação do Apache Tomcat.

Se você tiver problemas e precisar de ajuda, leia a página de ajuda e faça sua pergunta na lista de discussão dos usuários do tomcat. Não faça essas perguntas aqui. Esta não é uma seção de perguntas e respostas.

O sistema de comentários do Apache é explicado aqui. Os comentários podem ser removidos por nossos moderadores se forem implementados ou considerados inválidos/fora do tópico.

Tomcat Log4J Configuração passo a passo

Servidor Apache Tomcat J2EE

Juli Logging Library and Configuration está disponível por padrão com o instalador Tomcat. Para usar o log4j para o log de Tomcat, em vez disso, você precisará substituir a biblioteca Juli existente pela integração log4j-juli.

1. Excluir biblioteca Juli existente (Catalina_home/bin/tomcat-juli.arquivo de jar) e o arquivo de configuração de log do tomcat existente (Catalina_home/conf/logging.propriedades).

2. Baixe a biblioteca Juli Log4J Tomcat (Tomcat-Juli.jar) dos downloads do tomcat’ Seção extras (http: // tomcat.apache.org/download-70.CGI). Coloque o arquivo baixado para Catalina_home/Bin Directory.

3. Baixar Tomcat Juli Adapts Library (Tomcat-Juli-Adapters.jar) dos downloads do tomcat’ Seção extras. Coloque este arquivo no diretório catalina_home/lib.

4. Baixe Log4J (versão 1.2 ou mais tarde) e coloque o arquivo da biblioteca baixado para o diretório Catalina_home/lib.

5. Crie o arquivo de configuração log4j no seguinte local: Catalina_home/lib/log4j.propriedades. Verifique abaixo a configuração do log4j correspondendo à configuração de log Java padrão.

6. Reinicie o tomcat.

Arquivo de configuração log4j correspondendo às configurações de log do tomcat padrão:

log4j.rootLogger = informações, catalina # define todos os apêndeiros log4j.Appender.Catalina = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.Catalina.Arquivo = $/logs/catalina. log4j.Appender.Catalina.Anexar = True Log4J.Appender.Catalina.Coding = utf-8 # roll-over o log uma vez por dia log4j.Appender.Catalina.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.Catalina.layout = org.apache.log4j.PatternLayout Log4J.Appender.Catalina.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Localhost = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.LocalHost.Arquivo = $/logs/localhost. log4j.Appender.LocalHost.Anexar = True Log4J.Appender.LocalHost.Coding = utf-8 log4j.Appender.LocalHost.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.LocalHost.layout = org.apache.log4j.PatternLayout Log4J.Appender.LocalHost.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Gerente = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.GERENTE.Arquivo = $/logs/gerente. log4j.Appender.GERENTE.Anexar = True Log4J.Appender.GERENTE.Coding = utf-8 log4j.Appender.GERENTE.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.GERENTE.layout = org.apache.log4j.PatternLayout Log4J.Appender.GERENTE.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Host-manager = org.apache.log4j.DailyrollingFilePpender LOG4J.Appender.Host-gerente.Arquivo = $/logs/host-manager. log4j.Appender.Host-gerente.Anexar = True Log4J.Appender.Host-gerente.Coding = utf-8 log4j.Appender.Host-gerente.DatePattern = '.'yyyy-mm-dd'.log 'log4j.Appender.Host-gerente.layout = org.apache.log4j.PatternLayout Log4J.Appender.Host-gerente.layout.Conversãopattern = %d [ %t] %-5p %c- %m %n log4j.Appender.Console = org.apache.log4j.ConsoleAppender Log4J.Appender.CONSOLE.Coding = utf-8 log4j.Appender.CONSOLE.layout = org.apache.log4j.PatternLayout Log4J.Appender.CONSOLE.layout.ConversionPattern = %d [ %t] %-5p %c- %m %n # configure quais loggers log no qual apêndices log4j.Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[localhost] = Info, localhost Log4J.Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].[/gerente] = Informações, gerente Log4J.Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].[/Host-manager] = Informações, Host-manager

Tomcat agora usará o log4j para todos os registros internos.

Para entender acima da configuração, verifique os detalhes abaixo para obter uma visão clara

Elementos de configuração para log4j’s PatternLayout

%d Data de registro. Você pode especificar o padrão de data entre colchetes ( %d) %c nome de classe totalmente qualificado (use %c para imprimir apenas o nome da classe simples) %t Nome do thread em que o registro ocorreu %f nome do arquivo do evento de registro %P Nível de registro %L Número da linha do padrão de madeira

Aqui estão alguns dos exemplos de padrões e as entradas de log que eles geraram:

%d [ %t] %-5p %c- %m %n 2011-09-07 14: 07: 41.509 [principal] informações myntclass-executando.

%5p [%t] (%f:%l) -%m%n info [principal] (myntclass.Java: 12) - executando.

Para obter mais informações sobre o link Log4J da compra abaixo:

http: // log.apache.org/log4j/índice.html

No caso de qualquer problema de © Copyright ou Falta Créditos, verifique os direitos autorais para obter resoluções mais rápidas.

Como o artigo. Compartilhe.

  • Clique para imprimir (abre na nova janela)
  • Clique para enviar um link por e -mail para um amigo (abre na nova janela)
  • Clique para compartilhar no Reddit (abre na nova janela)
  • Clique para compartilhar no Pinterest (abre na nova janela)
  • Clique para compartilhar no LinkedIn (abre na nova janela)
  • Clique para compartilhar no WhatsApp (abre na nova janela)
  • Clique para compartilhar no Twitter (abre na nova janela)
  • Clique para compartilhar no Facebook (abre na nova janela)
  • Clique para compartilhar no Tumblr (abre na nova janela)
  • Clique para compartilhar no bolso (abre na nova janela)
  • Clique para compartilhar no telegrama (abre na nova janela)
  • Clique para compartilhar no Skype (abre na nova janela)

Como fazer: Configure o TomCat 9 para fazer login via log4j2

Como você pode redirecionar o registro interno do Tomcat 9 (Catalina e Localhost) para Log4j2? Embora existam muitos guias disponíveis para versões mais antigas do TomCat e Log4J, não consegui encontrar nada “completo” sobre o Tomcat 9 e o Log4J2; A documentação do Apache Tomcat 9 aponta para “as instruções fornecidas pela estrutura alternativa de registro” e os estados da documentação do Apache Log4J (nomes de jarro em 2. corrigido):

  1. Criando um conjunto de diretórios na Catalina Home chamado log4j2/lib e log4j2/conf.
  2. Colocando log4j-api-2.12.0.jar, log4j-core-2.12.0.jar e log4j-AppServer-2.12.0.jar no diretório log4j2/lib.
  3. Criando um arquivo chamado log4j2-tomcat.xml, log4j2-tomcat.JSON, LOG4J2-TOMCAT.Yaml, log4j2-tomcat.YML, ou LOG4J2-TOMCAT.Propriedades no diretório log4j2/conf.
  4. Crie ou modifique o SETENV.SH no diretório Tomcat bin para incluir classe = $ catalina_home/log4j2/lib/*: $ catalina_home/log4j2/conf

Mas o que colocar nesse log4j2-tomcat.* arquivo de configuração?

perguntou 5 de julho de 2019 às 12:33

682 1 1 CLAGE DE OURO 6 6 crachás de prata 17 17 crachás de bronze

2 respostas 2

Encontrei um arquivo de propriedades de amostra na documentação Apache Tomcat 7, mas como isso é destinado ao uso com o LOG4J 1.x, tive que adaptá -lo à sintaxe do arquivo de propriedades log4j2. Este é o resultado:

ass.Loglevel.Catalina = propriedade de informações.Loglevel.LocalHost = Propriedade de informações.layoutpattern.catalina = %d %-5p [ %t] %-22.22c %m %n propriedade.layoutpattern.localhost = %d %-5p [ %t] %-30.30c %m %n # roll-over os troncos uma vez por mês usando o CrontriggerPolicy. propriedade.FiledatePattern.Catalina = %D Propriedade.FiledatePattern.localhost = %d propriedade.Correrggerschedule.Catalina = 0 0 0 1 * ? propriedade.Correrggerschedule.localhost = 0 0 0 1 * ? ## Apêndios # n.B.: - Não há necessidade de especificar 'Apêndios = Catalina, Localhost, Console' # Como esses identificadores não contêm '.' personagens. # - As 'políticas' dos identificadores de subcomponente e 'cron' são arbitrariamente # escolhidas; O tipo real é especificado através do atributo 'tipo'. Ass. Appender.Catalina.TIPO = ROLLINGFILE APPERNE.Catalina.Nome = RollingFile-Catalina Appender.Catalina.filepattern = $/logs/catalina.$.Log Appender.Catalina.layout.TIPO = APPERNO PATDINGLayout.Catalina.layout.padrão = $ appender.Catalina.políticas.Tipo = políticas Appender.Catalina.políticas.Cron.Tipo = CRontriggeringPolicy Appender.Catalina.políticas.Cron.cronograma = $ appender.Catalina.políticas.Cron.avaliarenstartup = True Appender.Catalina.FILEPERMISSIONS = RW-R ----- Appender.Catalina.Filewner = Tomcat Appênder.Catalina.FileGroup = ADMP APPERN.LocalHost.TIPO = ROLLINGFILE APPERNE.LocalHost.Nome = ROLLINGLINGFILE-LOCALHOST APPERNE.LocalHost.filepattern = $/logs/localhost.$.Log Appender.LocalHost.layout.TIPO = APPERNO PATDINGLayout.LocalHost.layout.padrão = $ appender.LocalHost.políticas.Tipo = políticas Appender.LocalHost.políticas.Cron.Tipo = CRontriggeringPolicy Appender.LocalHost.políticas.Cron.cronograma = $ appender.LocalHost.políticas.Cron.avaliarenstartup = True Appender.LocalHost.FILEPERMISSIONS = RW-R ----- Appender.LocalHost.Filewner = Tomcat Appênder.LocalHost.FileGroup = ADM # Uncomment se você quiser continuar fazendo log no Catalina.fora após o log4j2 assumir o controle. #appender.CONSOLE.tipo = console #appender.CONSOLE.nome = stdout #appender.CONSOLE.layout.TIPO = PatternLayout ## Configure quais loggers registram para quais apêndeiros rootlogger.nível = $ rootlogger.AppenderRef.Catalina.ref = rollingfile-catalina #rootlogger.AppenderRef.stdout.ref = stdout # aqui, o identificador contém '.personagens, então devemos especificar a lista. Loggers = org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost] Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].Nome = LocalHost Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].nível = $ Logger.org.apache.Catalina.essencial.Contêinerbase.[Catalina].[Localhost].AppenderRef.LocalHost.Ref = Rollingfile-Localhost

O principal motivo para eu usar o log4j2 foi poder obter rotação mensal de log, mas você pode ajustar facilmente tudo o que quiser, mesmo sem reiniciar o tomcat.