Plug-in-Projekt für Protokollparser implementieren

Voraussetzungen

Nach dem Erstellen eines Plug-in-Projekts zum Speichern der Artefakte für einen Protokollparser müssen Sie das Plug-in konfigurieren, damit es von der Protokoll- und Traceanalysefunktion verwendet werden kann. Gehen Sie folgendermaßen vor:

  1. Fügen Sie der Plug-in-Manifestdatei Plug-in-Abhängigkeiten hinzu.
  2. Fügen Sie der Plug-in-Manifestdatei einen Erweiterungspunkt für den Protokollparser hinzu.
  3. Fügen Sie einen Erweiterungspunkt für statische Parser hinzu
  4. Erstellen sie eine Wrapper-Parserklasse
  5. Prüfen Sie die Einstellungen des Protokollparser-Plug-ins
  6. Packen Sie den Protokollparser
  7. Implementieren Sie den Protokollparser

1. Plug-in-Abhängigkeiten hinzufügen

Die nachstehenden Plug-in-Abhängigkeiten müssen in die Plug-in-Manifestdatei integriert werden. Öffnen Sie die Datei 'plugin.xml' in einem Texteditor. Lokalisieren Sie in der Datei das erforderliche Element und fügen Sie die Plug-in-Abhängigkeiten hinzu. Beispiel:

   
<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>

Hinweis: Die oben angegebenen erforderlichen Plug-ins müssen sich entweder im Verzeichnis für Eclipse-Plug-ins befinden, oder in den aktuellen Arbeitsbereich integriert werden.


2. Erweiterungspunkt für Protokollparser hinzufügen

Sie müssen einen Erweiterungspunkt für jeden Typ einer Anwendungsprotokolldatei definieren, die Sie analysieren und in die Analysefunktion für Protokoll und Trace importieren möchten. Im Folgenden sehen Sie ein Beispiel für eine Erweiterungspunkt für die MyApp-Anwendung, in dem sowohl ein Regeladapter als auch ein statischer Adapter definiert ist:

 <extension
         point="org.eclipse.hyades.logging.parsers.logParser">
	      <parser
            name="Sample Rules Adapter for MyApp"
            icon=""
            description="%STR_MYAPP_PARSER_DESCRIPTION"
            class="RulesParser.StaticParserExtension"
            ui_name="MyApp myapp.log file"
            id="org.eclipse.hyades.logging.parsers.MyAppLogParser">  
         <field
               useBrowse="true"
               defaultValue="d:\temp\sample.log"
               name="Directory"
               helpContextId=""
               tooltip="%STR_MYAPP_TOOLTIP1"
               id="file_path"
               browseType="*.log">
         </field>         
         <field
               useBrowse="false"
               defaultValue="MyApp 1.0(rules), MyApp 1.0(static)"
               name="Supported versions"
               helpContextId=""
               tooltip="%STR_MYAPP_TOOLTIP2"
               ui_type="combobox"
               id="version">
         </field>
         <parserParameter
               name="MyApp 1.0(rules)"
               value="./MyAdapter/myadapter.adapter">
    </parserParameter>
	<parserParameter
               name="MyApp 1.0(static)"
               value="./MyAdapter/mystaticadapter.adapter">
         </parserParameter>

      </parser>
   </extension>

Um den Erweiterungspunkt für Ihren Protokollparser anzupassen, müssen die folgenden Aktualisierungen vorgenommen werden:

  1. Ersetzen Sie 'RulesParser' in diesem Erweiterungspunkt durch den Namen des Plug-ins, das Sie für das Protokollparser-Plug-in-Projekt erstellt haben.
  2. Ersetzen Sie 'MyAdapter' in diesem Erweiterungspunkt durch den Namen des Ordners in Ihrem Plug-in, der Ihre Adapterdateien enthält.
  3. Das Tag <parser> spezifiziert Informationen der oberen Ebene für den Parser und ist ein erforderliches Element. Ersetzen Sie die folgenden Attribute:
  4. Das erste Tag <field> definiert das Benutzerschnittstellenfeld für die Auswahl der Position der Protokolldatei. Es handelt sich um ein erforderliches Element. Ersetzen Sie die folgenden Attribute:
  5. Das zweite Tag <field> definiert das kombinierte Benutzerschnittstellenfeld für die Auswahl der Version der zu importierenden Protokolldatei. Es handelt sich um ein erforderliches Element. Ersetzen Sie die folgenden Attribute:
  6. Das Tag <parserParameter> definiert, welche Adapter-Konfigurationsdatei für jede unterstützte Protokolldateiversion zu verwenden ist. Ersetzen Sie die folgenden Attribute:
Hinweis: Es sollte ein Standardwert definiert werden, für den Fall, dass keine Übereinstimmung für eine Version gefunden werden kann. Wenn Sie nur eine Adapter-Konfigurationsdatei haben, benötigen Sie nur den Standardwert parserParameter. Beispiel:
<parserParameter
   name="Default"
   value="./MyAdapter/myadapter.adapter">
</parserParameter>

Anhand der oben angegebenen Felder wird eine Option für 'MyApp myapp.log' im Assistenten 'Protokolldatei importieren' erstellt, wie nachstehend gezeigt:

Assistent 'Protokolldatei importieren' mit 'myapp myapp.log' als Option zum Importieren

Sie können eine Datei 'plugin.properties' verwenden, um bestimmte Eigenschaften in der Datei 'plugin.xml' zu definieren, die eventuell verschiedene Versionen haben muss. Wenn es z.B. in dem Assistenten für den Import von Protokolldateien Zeichenfolgen gibt, die in verschiedene Sprachen übersetzt werden müssen, können diese in der Datei 'plugin.properties' definiert werden und Sie können verschiedene Eigenschaftsdateien für die Sprachen, die Sie unterstützen möchten, aufnehmen. In der Datei 'plugin.properties' definieren Sie Ersatzvariablen, die in der Datei 'plugin.xml' verwendet werden können. Die Datei 'plugin.properties' für die vorstehende Datei 'plugin.xml' würde wie folgt aussehen:


# Eigenschaften für das Plug-in RulesParser

pluginName = RulesParser
providerName = MeineFirma

# Nachricht(en) für den Erweiterungspunkt des Protokollparsers:
STR_MYAPP_PARSER_DESCRIPTION = 'MyApp' - Regelbasierter Parser v1.0
STR_MYAPP_TOOLTIP1           = Speicherposition der Protokolldatei eingeben
STR_MYAPP_TOOLTIP2           = Version der zu importierenden Protokolldatei auswählen

Hinweis: Je nach Ländereinstellung, in der eine Anwendung ausgeführt wird, kann sie Daten in verschiedenen Sprachen in ihre Protokolldatei schreiben. Statische Parserklassen und Regeln mit regulären Ausdrücken sind so geschrieben, dass sie eine Protokolldatei in einer einzigen Sprache syntaktisch analysieren. Zur Unterstützung eines Protokolldateityps, der in mehreren Sprachen geschrieben werden kann, muss daher eine separate statische Parseradapterdatei bzw. Regeladapterdatei für jede Sprache erstellt werden. Danach sollte im Erweiterungspunkt 'logParser' dieses Protokolldateityps ein Tag 'parserParameter' für jede Adapterdatei eingefügt werden, das die Sprache angibt, die es auf das Namensfeld anwendet. Vergessen Sie nicht, die Namenswerte 'parserParameter' zur Liste im Attribut 'defaultValue' des Versionsfeldes hinzuzufügen. So kann ein Benutzer beim Import einer Protokolldatei die richtige Sprache der Protokolldatei auswählen.

Die folgenden Parserparameter können beispielsweise zum Erweiterungspunkt 'logParser' hinzugefügt werden, um den Import von englischen, französischen und deutschen Protokollen zu unterstützen:

	<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. Erweiterungspunkt für statischen Parser hinzufügen

Dieser Schritt ist für die Erstellung eines statischen Parsers erforderlich.

Für statische Parser muss die von Ihnen erstellte statische Parserklasse in der Datei plugin.xml über eine Erweiterung staticParser angegeben werden. Über diesen Erweiterungspunkt kann die Klasse gefunden werden, wenn sie zur syntaktischen Analyse einer Datei im Protokollimportszenario verwendet werden soll.
Fügen Sie den folgenden Erweiterungspunkt hinzu:

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

Ersetzen Sie myLogParser33.MyStaticParser mit dem Klassennamen Ihres Java-Parsers.

4. Wrapperklasse für Parser erstellen

Erstellen Sie eine statische Wrapperklasse zur Erweiterung von org.eclipse.hyades.logging.adapter.config.StaticParserWrapper. Diese Klasse wird von sowohl statischen als auch regelbasierten Parsern verwendet, um über die Laufzeit des generischen Protokolladapters die Adapterkonfigurationsdatei, die der vom Benutzer im Assistenten für den Protokollimport ausgewählten Version zugeordnet ist, auszuführen.

/*
 * Erstellt am 12. April 2004
 * StaticParserExtension-Klasse zur Verwendung im RulesParser-Plug-in erstellt
 */
package RulesParser;

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

/**
 * @Autor/Entwickler
 * StaticParserExtension-Klasse
 */
public class StaticParserExtension extends StaticParserWrapper {
	public StaticParserExtension(){
		super();
		currentPlugin="RulesParser"; 
	}
}

5. Einstellungen des Protokollparser-Plug-ins prüfen

Um zu prüfen, ob Sie die Plug-in-Manifestdatei korrekt konfiguriert haben, können Sie Ihr Plug-in-Projekt in einer neuen Laufzeit-Workbench ausführen. Gehen Sie folgendermaßen vor:

  1. Wechseln Sie zur Perspektive 'Plug-in', indem Sie Fenster > Perspektive öffnen > Andere > Plug-in-Entwicklung auswählen.
  2. Wählen Sie in der Perspektive 'Plug-in-Entwicklung' Ihr Plug-in-Projekt aus.
  3. Wählen Sie in der Symbolleiste Ausführen > Ausführen als > Laufzeit-Workbench aus.
  4. Wählen Sie im Menü der neuen Workbench Datei > Importieren aus.
  5. Wählen Sie im Importassistenten Protokolldatei aus und klicken dann auf Weiter.
  6. Auf der Seite 'Protokolldateien' klicken Sie auf Hinzufügen, um eine Protokolldatei hinzuzufügen. Prüfen Sie in dem Fenster 'Protokolldatei hinzufügen', ob sich Ihr neuer Protokolldateityp in der Liste Ausgewählte Protokolldatei befindet.
  7. Wählen Sie Ihren Protokolldateityp aus. Prüfen Sie, ob alle Felder und Texte auf der Registerkarte Details korrekt sind.
  8. Geben Sie den Wert für die Position der Protokolldatei an.
  9. Klicken Sie auf OK.
  10. Klicken Sie auf Fertig stellen, um die Protokolldatei in Ihren neuen Protokolldateityp zu importieren. Prüfen Sie, ob die Protokolldateisätze in der Sicht 'Protokoll' angezeigt werden.
    Hinweis: Wenn in der Sicht 'Protokoll' keine Protokolldatensätze angezeigt werden, prüfen Sie, ob die Ausgabeprogrammkomponente in der Adapterkonfigurationsdatei des Parsers mit der Ausführungsklasse org.eclipse.hyades.logging.adapter.config.outputters.StaticParserOutputter konfiguriert ist.

6. Protokollparser-Plug-in packen und implementieren

Lokale Implementierung

Um Ihr Protokollparser-Plug-in in eine Eclipse-Workbench zu implementieren, müssen Sie die Plug-in-Dateien packen, indem Sie sie in eine ZIP-Datei exportieren. Gehen Sie folgendermaßen vor:

  1. Öffnen Sie die Datei 'plugin.xml' mit dem Editor für Plug-in-Manifeste.
  2. Wählen Sie die Registerkarte Laufzeit und stellen Sie sicher, dass die Liste Laufzeitbibliotheken eine JAR-Datei für Ihre Plug-in-Klassen enthält. Ist hier keine JAR-Datei aufgeführt, fügen Sie eine hinzu, indem Sie auf die Schaltfläche Neu... klicken und einen geeigneten Namen eingeben.
  3. Wählen Sie die Registerkarte Build aus und markieren Sie die entsprechenden Dateien und Ordner in der Liste Binärer Build, die in Ihrem exportieren Plug-in enthalten sein wird. Wählen Sie beispielsweise die Dateien plugin.xml, plugin.properties und die Adapterkonfigurationsdateien für den Parser aus. Speichern Sie die Änderungen an der Datei plugin.xml.
  4. Exportieren Sie die Plug-in-Dateien, indem Sie Datei > Exportieren auswählen.
  5. Wählen Sie im Exportassistenten > Implementierbare Plug-ins und Fragmente aus.
  6. Klicken Sie auf Weiter.
  7. Wählen Sie auf der Seite 'Plug-ins und Fragmente exportieren' aus der Liste Verfügbare Plug-ins und Fragmente Ihr Plug-in aus und aktivieren Sie das entsprechende Markierungsfeld.
  8. Wählen Sie im Feld 'Exportoptionen' die Option 'Implementieren als eine einzelne ZIP-Datei' aus.
  9. Geben Sie den Ziel-Dateinamen für die ZIP-Datei an.
  10. Klicken Sie auf Fertig stellen.

Fernimplementierung

Um Ihren Protokollparser auf einem fernen Host zu implementieren, so dass Sie Protokolldateien von diesem fernen Host importieren können, müssen Sie eine Agent Controller-Plug-in-Konfigurationsdatei für Ihren Protokollparser erstellen. Gehen Sie folgendermaßen vor:
  1. Öffnen Sie die Datei 'plugin.xml' mit dem Editor für Plug-in-Manifeste.
  2. Wählen Sie die Registerkarte Laufzeit und stellen Sie sicher, dass die Liste Laufzeitbibliotheken eine JAR-Datei für Ihre Plug-in-Klassen enthält. Ist hier keine JAR-Datei aufgeführt, fügen Sie eine hinzu, indem Sie auf die Schaltfläche Neu... klicken und einen geeigneten Namen eingeben.
  3. Erstellen Sie in Ihrem Protokollparser-Plug-in einen Ordner namens 'config'.
  4. Erstellen Sie in dem Ordner 'config' eine Datei namens 'pluginconfig.xml'. Beispiel:

    <?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. Ersetzen Sie RulesParser durch den Namen Ihres Protokollparser-Plug-in-Projekts.
  6. Öffnen Sie die Datei 'plugin.xml' mit dem Editor für Plug-in-Manifeste.
  7. Wählen Sie die Registerkarte Build aus und markieren Sie die entsprechenden Dateien und Ordner in der ListeBinärer Build, die in Ihrem exportieren Plug-in enthalten sein wird. Wählen Sie beispielsweise die Dateien plugin.xml, plugin.properties und die Adapterkonfigurationsdateien für den Parser aus, sowie die soeben erstellte Datei 'pluginconfig.xml'. Speichern Sie die Änderungen an der Datei plugin.xml.
  8. Exportieren Sie die Plug-in-Dateien, indem Sie Datei > Exportieren auswählen.
  9. Wählen Sie im Exportassistenten > Implementierbare Plug-ins und Fragmente aus.
  10. Klicken Sie auf Weiter.
  11. Wählen Sie auf der Seite 'Plug-ins und Fragmente exportieren' aus der Liste Verfügbare Plug-ins und Fragmente Ihr Plug-in aus, und aktivieren Sie das entsprechende Markierungsfeld.
  12. Wählen Sie im Feld 'Exportoptionen' die Option 'Implementieren als eine einzelne ZIP-Datei' aus.
  13. Geben Sie den Ziel-Dateinamen für die ZIP-Datei an.
  14. Klicken Sie auf Fertig stellen.

7. Implementierung Ihres Protokollparsers

Sie können Ihr Protokollparser-Plug-in implementieren, indem Sie die gerade erstellte ZIP-Datei in das eclipse-Verzeichnis einer Eclipse-Installation extrahieren. Nun können Sie unter Verwendung der Protokoll- und Traceanalysefunktion Ihr neu erstelltes Protokollparser-Plug-in testen.

Um Ihr Protokollparser-Plug-in auf einem fernen System zu implementieren, so dass eine Protokolldatei fern importiert werden kann, extrahieren Sie die gerade erstellte ZIP-Datei in das Agent Controller-Installationsverzeichnis auf dem fernen System. Starten Sie den Agent Controller erneut.

 

Verwandte Konzepte
Spezifikation des Common Base Event-Formats

Verwandte Aufgaben
Protokollparser erstellen
Statischen Adapter erstellen
Regelbasierten Adapter erstellen
Protokollparser testen
Plug-in-Projekt für Protokollparser einrichten

Verwandte Verweise
Struktur der Adapterkonfigurationsdatei
Editor für Adapterkonfiguration
Grammatik von regulären Ausdrücken