Implementando o Projeto de Plug-in do Analisador de Log

Pré-requisitos

Depois de criar um projeto de plug-in para conter os artefatos para um analisador de log, é necessário configurar o plug-in para que possa ser utilizado pelo Analisador de Log e Rastreio. Execute as seguintes etapas:

  1. Incluir Dependências de Plug-in no Arquivo de Manifesto do Plug-in
  2. Incluir um Ponto de Extensão para o Analisador de Log no Arquivo de Manifesto do Plug-in
  3. Incluir um Ponto de Extensão para Analisadores Estáticos
  4. Criar uma Classe de Analisador Wrapper
  5. Verificar as Definições de Plug-in do Analisador de Log
  6. Empacotando o Analisador de Log
  7. Implementando o Analisador de Log

1. Incluir Dependências de Plug-in

As dependências de plug-in a seguir devem ser incluídas no arquivo de manifesto de plug-in. Abra o arquivo plugin.xml em um editor de texto. Localize o elemento necessário no arquivo e inclua as dependências de plug-in nele. Por exemplo:

   
      <import plugin="org.eclipse.core.runtime"/>
   <requires>
 <import plugin="org.eclipse.hyades.logging.adapter"/>
 <import plugin="org.eclipse.hyades.logging.parsers"/>
 <import plugin="org.eclipse.hyades.logging.adapter.config"/>
   </requires>

Nota: Os plug-ins exigidos especificados acima deve estar localizados no diretório plugins do eclipse ou devem ser incluídos no espaço de trabalho atual.


2. Incluir um Ponto de Extensão de Analisador de Log

Você precisa definir um ponto de extensão para cada tipo de arquivo de log do aplicativo que deseja analisar e importar para o Log and Trace Analyzer. A seguir há um ponto de extensão de amostra para o aplicativo MyApp com um adaptador de regras e um adaptador estático definidos:

 <extension
         point="org.eclipse.hyades.logging.parsers.logParser">
	      <parser
            name="Adaptador de Regras de Amostra para MyApp"
            icon=""
            description="%STR_MYAPP_PARSER_DESCRIPTION"
            class="RulesParser.StaticParserExtension"
            ui_name="Arquivo MyApp myapp.log"
            id="org.eclipse.hyades.logging.parsers.MyAppLogParser">
         <field
               useBrowse="true"
               defaultValue="d:\temp\sample.log"
               name="Diretório"
               helpContextId=""
               tooltip="%STR_MYAPP_TOOLTIP1"
               id="file_path"
               browseType="*.log">
         </field>
         <field
               useBrowse="false"
               defaultValue="MyApp 1.0 (regras), MyApp 1.0 (estático)"
               name="Versões suportadas"
               helpContextId=""
               tooltip="%STR_MYAPP_TOOLTIP2"
               ui_type="combobox"
               id="version">
         </field>
         <parserParameter
               name="MyApp 1.0 (regras)"
               value="./MyAdapter/myadapter.adapter">
         </parserParameter>
	<parserParameter
               name="MyApp 1.0 (estático)"
               value="./MyAdapter/mystaticadapter.adapter">
         </parserParameter>

      </parser>
 </extension>

Para customizar o ponto de extensão para o analisador de log, as atualizações precisam ser feitas:

  1. Substitua RulesParser neste ponto de extensão pelo nome do plug-in que você criou para o projeto de plug-in do analisador de log.
  2. Substitua MyAdapter neste ponto de extensão pelo nome da pasta no plug-in que contém os arquivos do adaptador.
  3. A marcação <parser> especifica informações de alto nível para o analisador e é um elemento requerido. Substitua os seguintes atributos:
  4. A primeira marcação <field> define o campo UI para selecionar o local do arquivo de log. Ela é um elemento requerido. Substitua os seguintes atributos:
  5. A segunda marcação <field> define a caixa de combinação UI, selecionando a versão do arquivo de log a ser importado. Ela é um elemento requerido. Substitua os seguintes atributos:
  6. A marcação <parserParameter> define qual arquivo de Configuração do Adaptador utilizar para cada versão de arquivo de log suportada. Substitua os seguintes atributos:
Sugestão: Um Default deve ser definido, caso não seja localizada uma correspondência para uma versão. Se você tiver somente um arquivo de configuração do adaptador, somente precisará ter o parserParameter padrão. Por exemplo:
         <parserParameter
   name="Default"
               value="./MyAdapter/myadapter.adapter">
         </parserParameter>

Os campos especificados acima criarão uma opção para o MyApp myapp.log no assistente Importar Log, conforme mostrado a seguir:

Assistente Importar Log mostrando o myapp myapp.log como uma opção para importação

Você pode utilizar um arquivo plugin.properties para definir determinadas propriedades no arquivo plugin.xml que poderá precisar ter versões diferentes. Por exemplo, se houver cadeias de texto a serem incluídas no assistente Importar Arquivo de Log, que precisam ser traduzidas para idiomas diferentes, elas poderão ser definidas no arquivo plugin.properties e você poderá incluir arquivos de propriedades diferentes para os idiomas aos quais deseja suporte. No arquivo plugin.properties, você define variáveis de substituição que podem ser utilizadas no arquivo plugin.xml. O arquivo plugin.properties para o plugin.xml acima seria semelhante a este:


# Propriedades para o Plug-in RulesParser

pluginName = RulesParser
providerName = MyCompany

# Mensagem(ns) do ponto de extensão logParser:
STR_MYAPP_PARSER_DESCRIPTION = Analisador de regras MyApp v1.0
STR_MYAPP_TOOLTIP1           = Digite o local do arquivo de log
STR_MYAPP_TOOLTIP2           = Selecione a versão do arquivo de log a ser importado

Sugestão: Um aplicativo pode gravar dados em sei arquivo de log em diferentes idiomas, dependendo do código do idioma no qual ele está executando. Classes de analisador estático ou regras de expressão comum são escritas para analisar um arquivo de log em um único idioma. Portanto, para suportar um tipo de arquivo de log que pode ser escrito em muitos idiomas, um arquivo adaptador de analisador estático ou um arquivo adaptador de regras separado precisa ser criado para cada idioma. Em seguida, no ponto de extensão do logParser para esse tipo de arquivo de log, um tag parserParameter deve ser incluído para cada tipo de adaptador, especificando o idioma ao qual ele se aplica no campo de nome. Não se esqueça de incluir os valores de nome de parserParameter na lista no atributo defaultValue do campo de versão. Isso permitirá que um usuário escolha o idioma correto do arquivo de log ao importar o arquivo de log.

Por exemplo, os parâmetros de analisador a seguir podem ser incluídos no ponto de extensão do logParser para suportar a importação de logs em inglês, francês e alemão:

	<parserParameter
	         	name="MyApp 1.0(rules) English"
	         	value="./MyAdapter/myadapter_en.adapter"/>
	<parserParameter
	         	name="MyApp 1.0(rules) French"
	         	value="./MyAdapter/myadapter_fr.adapter"/>
	<parserParameter
	         	name="MyApp 1.0(rules) German"
	         	value="./MyAdapter/myadapter_de.adapter"/>

3. Incluir um Ponto de Extensão para Analisadores Estáticos

Esta etapa é necessária se você estiver criando um analisador estático.

Para analisadores estáticos, a classe de analisador estático criada deve ser especificada no plugin.xml utilizando uma extensão staticParser. Esse ponto de extensão permitirá que a classe possa ser localizada quando for usada para analisar um arquivo no cenário de Importação de Log.
Inclua o seguinte ponto de extensão:

<extension
  point="org.eclipse.hyades.logging.adapter.config.staticParser">
  <parserClassname
    name="myLogParser33.MyStaticParser">
  </parserClassname>
 </extension>

Substitua myLogParser33.MyStaticParser pelo nome de sua classe de analisador Java.

4. Criar uma Classe Wrapper para o Analisador

Crie uma classe wrapper estática que estenda o org.eclipse.hyades.logging.adapter.config.StaticParserWrapper. Essa classe é usada para analisadores estáticos e baseados em regras para executar o arquivo de configuração do adaptador associado à versão selecionada pelo usuário no assistente Importar Log, utilizando o tempo de execução do Adaptador de Log Genérico.

/*
 * Criado em 12 de abril de 2004
 * Classe StaticParserExtension criada para ser utilizada no Plug-in RulesParser
 */
package RulesParser;

import org.eclipse.hyades.logging.adapter.config.StaticParserWrapper;

/**
 * @autor desenvolvedor
 * Classe StaticParserExtension
 */
public class StaticParserExtension extends StaticParserWrapper {
	public StaticParserExtension(){
		super();
		currentPlugin="RulesParser"; 
	}
}

5. Verificar as Configurações do Plug-in do Analisador de Log

Para verificar se configurou corretamente o arquivo de manifesto do plug-in, você poderá executar o projeto de plug-in em um novo workbench de tempo de execução. Execute as seguintes etapas:

  1. Mude para a perspectiva Plug-in, selecionando Janela > Abrir perspectiva > Outro> Desenvolvimento de Plug-in.
  2. Na perspectiva Desenvolvimento de Plug-in, selecione o projeto de plug-in.
  3. Na barra de ferramentas, selecione Executar > Executar Como > Workbench de Tempo de Execução.
  4. No novo workbench, no menu, selecione Arquivo > Importar.
  5. No assistente Importar, selecione Arquivo de Log e clique em Avançar.
  6. Na página Arquivos de Log, clique em Incluir para incluir um arquivo de log. Na janela Incluir Arquivo de Log, verifique se o novo tipo de arquivo de log está incluído na lista Arquivo de log selecionado.
  7. Selecione o tipo de arquivo de log. Verifique se todos os campos e texto na guia Detalhes está correto.
  8. Especifique o valor para o local do arquivo de log.
  9. Clique em OK.
  10. Clique em Concluir para importar o arquivo de log de seu novo tipo de arquivo de log. Verifique se os registros do arquivo de log são exibidos na Visualização Log.
    Sugestão: Se nenhum registro do arquivo de log for exibido na Visualização Log, verifique se o componente Outputter no arquivo de configuração do adaptador do analisador está configurado com a classe de execução org.eclipse.hyades.logging.adapter.config.outputters.StaticParserOutputter.

6. Empacotando e Implementando o Plug-in do Analisador de Log

Implementação Local

Para implementar o plug-in do analisador de log para um workbench do eclipse, é necessário empacotar os arquivos de plug-in exportando-os para um arquivo zip. Execute as seguintes etapas:

  1. Abra o arquivo plugin.xml com o editor de Manifesto de Plug-in.
  2. Selecione a guia Tempo de Execução e verifique se um arquivo jar para suas classes de plugin está incluído na lista de Bibliotecas de Tempo de Execução. Se não houver um arquivo jar listado, inclua um clicando no botão Novo... e especificando um nome apropriado.
  3. Selecione a guia Construir e marque os arquivos e as pastas apropriados na lista Construção de Binário que serão incluídos no plugin exportado. Por exemplo, marque os arquivos plugin.xml, plugin.properties e de configuração do adaptador do analisador. Salve as alterações no arquivo plugin.xml.
  4. Exporte os arquivos de plug-in, selecionando Arquivo > Exportar.
  5. NO assistente Exportar, selecione > Plugins e Fragmentos Implementáveis.
  6. Clique em Avançar.
  7. Na página Exportar Plugins e Fragmentos, selecione seu plug-in na lista de Plugins e Fragmentos Disponíveis e marque sua caixa de opções.
  8. Selecione implementar como um único arquivo ZIP no campo Opções de Exportação.
  9. Especifique o Nome do arquivo de destino para o arquivo zip.
  10. Clique em Concluir.

Implementação Remota

Para implementar o analisador de log em um host remoto para que possa importar os arquivos de log desse host remoto, você deve criar um arquivo de configuração de plug-in do Agent Controller para o analisador de log. Execute as seguintes etapas:
  1. Abra o arquivo plugin.xml com o editor de Manifesto de Plug-in.
  2. Selecione a guia Tempo de Execução e verifique se um arquivo jar para suas classes de plugin está incluído na lista de Bibliotecas de Tempo de Execução. Se não houver um arquivo jar listado, inclua um clicando no botão Novo... e especificando um nome apropriado.
  3. Crie uma pasta no plug-in do analisador de log chamada config.
  4. Crie um arquivo chamado pluginconfig.xml na pasta config. Por exemplo:

    <?xml version="1.0" encoding="UTF-8"?>
    <PluginConfiguration requires="org.eclipse.hyades.logging.parsers">
    <Application configuration="default" 
        executable="RemoteLogParserLoader" 
        extends="default" 
            location=="%SYS_TEMP_DIR%"
        path="%JAVA_PATH%">
    <Variable name="CLASSPATH" 
        position="prepend" 
        value="%RASERVER_HOME%\plugins\RulesParser_1.0.0\parsers.jar"/>
            <Variable name="GLA_CONFIG_PATH" position="prepend" value="%RASERVER_HOME%\plugins\RulesParser_1.0.0"/>
            <Parameter position="append" value=""config_path=%GLA_CONFIG_PATH%""/>
       </Application><Option name="RulesParser" type="version" value="1.0.0"/>
    </PluginConfiguration>
    

  5. Substitua RulesParser pelo nome do projeto de plug-in do analisador de log.
  6. Abra o arquivo plugin.xml com o editor de Manifesto de Plug-in.
  7. Selecione a guia Construir e marque os arquivos e as pastas apropriados na lista Construção de Binário que serão incluídos no plugin exportado. Por exemplo, marque os arquivos plugin.xml, plugin.properties, de configuração do adaptador do analisador e o arquivo pluginconfig.xml recém-criado. Salve as alterações no arquivo plugin.xml.
  8. Exporte os arquivos de plug-in, selecionando Arquivo > Exportar.
  9. No assistente Exportar, selecione > Plug-ins e fragmentos implementáveis.
  10. Clique em Avançar.
  11. Na página Exportar Plugins e Fragmentos, selecione seu plug-in na lista de Plugins e Fragmentos Disponíveis e marque sua caixa de opções.
  12. Selecione implementar como um único arquivo ZIP no campo Opções de Exportação.
  13. Especifique o Nome do arquivo de destino para o arquivo zip.
  14. Clique em Concluir.

7. Implementando o Analisador de Log

Você pode implementar o plug-in do analisador de log, descompactando o arquivo zip que acabou de criar no diretório eclipse de uma instalação do eclipse. Agora você está pronto para testar o plug-in do analisador de log recém-criado, utilizando o Log and Trace Analyzer.

Para implementar o plug-in do analisador de log em um sistema remoto para que um arquivo de log possa ser importado remotamente, descompacte o arquivo zip que acabou de criar no diretório de instalação do Agent Controller no sistema remoto. Reinicie o Agent Controller.

 

Conceitos Relacionados
Especificação do Formato Common Base Event

Tarefas Relacionadas
Criando um Analisador de Log
Criando um Adaptador Estático
Criando um Adaptador Baseado em Regras
Testando um Analisador de Log
Configurando um Projeto de Plug-in para um Analisador de Log

Referências Relacionadas
Estrutura do Arquivo de Configuração do Adaptador
Editor de Configuração de Adaptador
Gramática de Expressão Comum