Tutorial #2
Using and Extending the Test and Performance Tools
Platform (TPTP)
Eugene Chan
IBM Rational Software
Paul Slauenwhite
Agenda
Introductions
Speakers
Participants
What is Problem Determination?
Problem Statements
Taxonomy
Tooling
Benefits
Eclipse
TPTP Project
Mandate
Participants
Composition
Architecture
Agenda (continued)
TPTP EMF Data Models
Trace
Log
Statistical
Agent Controller
Architecture
Trace Agent
Logging Agents
Statistical Agents
Common Base Event
Design
Generic Log Adapter
Architecture
Adapters
Agenda (continued)
Logging Scenarios
Architecture
Logging Facility Support
Log and Trace Analyzer
Architecture
Importing and Monitoring
Profiling and Logging Perspective
Symptom Databases
Analysis
Correlation
Agenda (continued)
Demonstrations
Profiling and Logging Perspective
Launch Configuration
Attaching to a Java Application
Profiling Options
Profiling Views
Preferences
Statistical Monitoring and Analysis
Statistical Analysis Views
Generic Log Adapter
Logging Scenarios
Log File Parsers
Log View
Log Analysis
Log Correlation
Agenda (continued)
Conclusion
Project Extensibility
Future work
Resources
Questions, Answers and Discussion
IBM Sessions at EclipseWorld
Appendix 1- Java Logging XML Log File
Appendix 2- logger.dtd
Introductions - Speakers
Eugene Chan
Software Developer
IBM Rational Software
[email protected]
Paul Slauenwhite
Software Developer
IBM Rational Software
[email protected]
Introductions – Participants
Name and city.
Company or academic institution.
Eclipse and TPTP experience.
Tutorial objectives.
What is Problem Determination? - Problem Statements
Modern computing systems are becoming
more complex with the rapid development of
raw computing power (e.g. processing speed
and storage capabilities) and distributed
technologies.
Computing systems are more fragmented with
the proliferation of distributed technologies,
such as the Internet.
Numerous heterogeneous products and
applications are now required to build modern
computing systems.
Pervasive and ubiquitous computing devices
pose new management complexities.
Shortage of highly skilled workers to manage
and maintain complex heterogeneous
computing systems.
Problems are growing exponentially due to an
equally increasing use of complex computing
technology.
What is Problem Determination? - Taxonomy
Monitor, evaluate, detect, analyze, correlate, resolve and diagnose the root cause of
run-time problems in complex end-to-end heterogeneous computing systems.
Most computing systems generate log and/or trace data which is a rich source of system
activity and control flow information.
Useful for detecting and resolving run-time problems such as configuration errors,
performance degradation, exception states, resource starvation, security failures,
communication delays and deadlocking.
However:
Typically persisted in large (MB – GB) files.
Standards and terminology formats vary between vendor, product and version.
Varying levels of detail (e.g. terse and obscure).
Distributed systems scatter files across the network.
Textual viewing and manual searching or proprietary tooling.
No detailed explanation or solutions for records.
What is Problem Determination? - Tooling
Centralized tooling to collect and consolidate log and trace data from
disparate systems into a single management tool.
Based on open standards to be useful and to promote widespread adoption
in a heterogeneous environment.
Promotes a common event format for vendor, product and version-specific
log and trace formats.
Consumes a common event format for viewing, navigating, sorting, filtering
and searching large amounts of log and trace data.
Correlates log and trace records to determine sets of related events thereby
visualizing control flow across distributed systems.
Analyzes log and trace records to provide explanation and possible solutions
to known problems.
What is Problem Determination? - Benefits
Extensible open-source tools and technology with consistent and public
interfaces and points of control for industry-wide acceptance, agreement and
adoption.
Assist end-users, administrators, field service engineers and developers in
decreasing the time required for debugging, maintaining and securing
complex computing systems.
Increase return on administration investment by reducing maintenance costs
and improve asset utilization.
More efficient systems to better focus resources on business processes.
Rapid problem determination translates into increased system stability,
security, availability, resiliency and overall QoS.
Problem Determination =
Ø
Costs +
×
Stability
Eclipse
An open-source project dedicated to provide an universal, robust,
full-featured and commercial-quality platform written in Java for developing
Integrated Development Environments (IDEs).
Founded by IBM and other industry leaders in November 2001.
Composed of projects, each of which is overseen by a Project Management
Committee (PMC) and governed by its Project Charter.
Each project is composed of its own subprojects and is licensed under the
Eclipse Public License (EPL) starting in 2005.
TPTP Project - Mandate
Started in 2002 as an Eclipse tools subproject named Hyades.
Promoted in 2005 to an Eclipse project and renamed as the Test and Performance Tools Platform
(TPTP) project.
Open-source platform for Automated Software Quality (ASQ) tools including reference
implementations for testing, tracing and monitoring software systems.
Extensible framework and infrastructure that embraces automated testing, trace, profiling, monitoring,
and asset management.
Includes an unified data model, normative user experience and workflow and an united set of APIs
and reference tools that work consistently across a range of targets.
Principles:
Extension of the Eclipse Value Proposition Vendor Ecosystem
Vendor Neutrality
Standards-Based Innovation Agile Development
TPTP Project - Participants
Alphabetical order:
Computer Associates
Compuware
FOKUS
IBM
Intel
OC Systems
SAP
Scapa Technologies
TPTP Project - Composition
TPTP is composed of 4 projects:
Platform Test
Trace and Profiling Monitoring
Each project is divided into technology domains:
UI Analysis EMF Model Collection Control Communications Execution Agents/Events Doc
Each technology domain divided into components,
each with an assigned committer.
TPTP Project - Architecture
Presentation System
Test
Trace
EMF Data Models
Log
Statistical
XMI
Real Time
Export
Runtime
Monit
or / log
Trace An
alysis
And Profiling
an
Test Creation
d Execu
tio
n
Artifact
Management
Eclipse TPTP UI
Standard Widgets and
Core Plug-ins
Reference Perspectives
And Workflow
Target System
Data Collection
Application
Data Collection
Interface
Injection
Correlation
Execution
Environment
Log Collection
Trace Collection
System Performance
JVMPI Monitor
Data Loader
Distributed
Data Collection
Framework
Agent
Control Interface
Agent
Control Interface
Distributed
Control
Framework
Testability Interface
Test Engine
JVMTI Monitor
TBD
Eclipse Modeling Framework (EMF)
Framework and code generation facility for designing and implementing applications
based on a structured data model.
Data models are used to describe data objects, attributes and relationships.
Data models may be designed using annotated Java, XML, or UML class diagrams and
converted to an EMF model specification defined in XML Metadata Interchange (XMI).
The XMI model specification is used to generate the Java implementation classes for
the data model, a set of adapter Java classes that enable viewing and command-based
editing of the data model, and a basic editor UI.
The generated Java implementation classes are used to instantiate, load and persist
in-memory data models.
A resource persistence layer is provided to permit file system abstractions, such as a
relational database.
Provides a framework for the mechanical creation of data models that are the foundation
for interoperability with other EMF-based applications.
TPTP EMF Data Models
EMF data models are used in TPTP as an integration point.
TPTP UI is build on the TPTP EMF data models.
TPTP contains five EMF data models:
Trace
Log
Statistical
Test
Behavioural
Execution History
Data models are populated by model loaders consuming structured XML
fragments originating from a variety of sources.
TPTP EMF Data Models – Trace
Used to persist stand-alone application and distributed system trace
data.
Trace data consists of structured local or distributed execution and
heap information (e.g. Java process, thread, class and method
entry/exit with object instance and time).
Hierarchal data model capturing interaction at various levels of the
execution stacks and heap (e.g. method X in class Y on thread Z).
Provides framework for capturing statistical snapshot information
(e.g. method invocation counts).
Populated by local and remote profiling (e.g. JVMPI) instrumentation
and distributed tracing facilities.
TPTP EMF Data Models – Log
Used to persist problem determination data such as logging events and messages.
Defined by the Common Base Event v1.0.1 specification:
A common and standardized taxonomy for events occurring in hardware and software.
Unified format and terminology for the consistent interpretation of problem determination data
to circumvent varying vendor, product and version representations.
Hierarchal data model capturing textual message(s) and metadata, such as:
Time stamp
Source component
Situation
Severity
Populated by local and remote logging facilities, Logging Agents and batch importing of
log files.
TPTP EMF Data Models – Statistical
Used to persist arbitrary numerical data over time.
Hierarchal data model capturing structured statistical data defined
by descriptors.
Descriptors may contain child counter descriptors.
Descriptors contain snapshot observations that contain actual typed
statistical data:
Discrete (integer/time)
Contiguous (float/time)
String (String/time)
Agent Controller
Terminology:
Host process:
The process that contains the application under test.
Agent:
A reusable binary file that provides services to the host process,
and more importantly, provides a portal by which application data
can be forwarded to attached clients.
Client:
A local or remote application (eg Eclipse Workbench) that is the
terminal destination of host process data that is externalized by an
agent.
Agent Controller
Standalone component independent of the TPTP workbench.
Flexible daemon that resides on each local or remote deployment host.
Used to launch new processes and attach to agents that coexist within
processes.
Interacts with processes only on the same deployment host.
Provides extensible agent architecture for control capabilities and native data
collection.
Agent hosted within the Agent Controller may communicate data back to
monitoring clients (e.g. TPTP client).
TPTP client provides launch, attach, communication and data modelling
loading functionality.
Agent Controller – Architecture
RAC
Agent(s)
Sh.Mem Socket
CMD
Socket
Bindings
Local
TPTP
Client
Remote
TPTP
Client
DAT
Config
Agent Controller – Architecture
RAC
Agent(s)
Sh.Mem Socket
CMD
Socket
Bindings
DAT
Config
TPTP Client
Control
views
Loaders
Channel
Reader
Results
Views
Tools
EMF model
Storage
Command
Messages
Data
Messages
Agent Controller – Architecture
Supported platforms include:
AIX-RPC
HPUX-RISC
LINUX-IA32
LINUX-PPC64
LINUX-ZSERIES
OS/400-ISERIES
SOLARIS-SPARC
WINDOWS-IA32
Z/OS-ZSERIES
Agent Controller – Trace Agent
Java Virtual Machine Profiling Interface (JVMPI) agent implementation for
profiling local or remote Java applications from a local TPTP workbench to
capture and record an application's behavior.
Used for performance details such as classes or methods responsible for the
poor execution performance as well as to analyze application heap and
locate memory leaks.
Emits trace XML fragments based on a structured Event Specification for
Java Profiling (
trace.xsd
).
May be launched from the TPTP workbench or invoked using the -Xrun JVM
command line option.
A trace XML loader at the client side receives and parses the trace XML
fragments returned from any agent.
Agent Controller – Logging Agents
XML message-based agent for real-time monitoring of message
generating facilities (e.g. loggers).
Extensible architecture for crafting proprietary Logging Agents:
Defined APIs and programming model.
C implementation with a Java wrapper for supporting C/++ and Java
run-times.
TPTP provides Logging Agent support for several popular
Java-based logging and tracing facilities.
Agent Controller – Statistical Agents
XML message-based agent for real-time monitoring of operating systems, web servers, database
servers and application servers:
Windows System Performance Data (Perfmon) Linux System Perfmon Data
JBoss Application Server JMX Data JOnAS Application Server JMX Data Apache/IHS server-status Data
MySQL Database Table and Variable Data
Emits statistical XML fragments based on a structured schema (statistical.xsd).
Examples of operating system metrics include:
CPU usage. Network activity. Disk activity. Memory usage.
Views to effectively visualize the large amount and varying types of statistical data in real-time.
Extensible architecture for crafting proprietary Statistical Agents:
Common Base Event
Open-source specification (OASIS) to provide a common and standardized
taxonomy for events occurring in hardware and software.
Unified format and terminology for the standardized exchange and consistent
interpretation of problem determination data to circumvent varying vendor,
product and version representations.
Provides a mutual format for event data enabling the interoperability of
problem determination technologies and tooling thereby decreasing the costs
of managing complex computing systems.
Designed to abstractly describe all events within a multi-component system
but sufficiently granular to describe any occurrence or incident.
Common Base Event XML schema defines the overall structure of the event,
format of each property and all mandatory properties for completeness.
TPTP provides EMF consumer (e.g. model artifacts) Java, EMF producer
(e.g. native logging) Java, non-EMF Java and C/C++ implementations.
Common Base Event - Design
Events consist of message(s) and
metadata resulting from an occurrence
or situation including autonomic,
logging, tracing, management and
business situations.
Events are derived from situations that
are based on a structured 3-tuple
format:
Situation data, the properties
describing the situation including
correlation information.
Component impacted by a
situation, or the source
Component observing a situation
All other required and optional event
properties provide context for the
situation.
Generic Log Adapter
Tooling that transforms log and
trace data in proprietary formats
into the Common Base Event
format for use as a problem
determination resource.
Assists developers in adapting log
and trace data to the Common
Base Event format without
re-writing existing applications.
Originated from IBM Research as
a mechanism to cheaply enable
Common Base Event compliance
in legacy computing systems.
Generic Log Adapter - Architecture
Based on a pluggable pipe and
filter architecture.
Filters or components are
organized by contexts which are
associated with one specific data
set.
Scalable to support large amounts
(MB – GB) of log and trace data.
Four modes of operation:
Batch or continuous.
Static or rules.
Generic Log Adapter – Adapters
Transforms are defined in adapter files:
Contains one or more contexts and the components for each context.
Stored as XML based on a defined schema.
Parsing component incorporates mapping proprietary log and trace
record properties to Common Base Event properties using mapping
rules.
Rules are defined using static strings or regular expressions (e.g. Perl).
Static Java parsers may be used to parse data.
Adapter Configuration Editor provides a tool to write, debug and test
adapter files using a template log file.
Adapter files may be mechanically converted into Log File parsers for
use in the Log and Trace Analyzer.
Logging Scenarios
New or redesigned systems may be instrumented to natively generate Common
Base Events using the producer Java implementation.
However:
Java-based logging and tracing facilities often enforce proprietary record formats.
No existing integration with tooling for real-time monitoring of loggers and logged records.
Hyades provides the following support for several popular Java-based logging and
tracing facilities:
Common Base Event logging.
Logging Agent sinks.
Filtering.
Configuration.
Formatting.
Logging Scenarios - Architecture
Client
Server
Logging Scenarios - Logging Facility Support
TPTP provides Common Base Event and Logging Agent standalone
and plug-in support for the following popular logging facilities:
Jakarta Apache Commons
Java Logging (JSR-047)
Jakarta Apache Log4J
Extensible architecture for crafting proprietary Logging Agents:
Log and Trace Analyzer
Eclipse-based tooling for collecting, persisting, viewing, navigating,
sorting, filtering and searching EMF model data.
Permits users to monitor, evaluate, detect, analyze, correlate,
resolve and diagnose the root cause of run-time problems in
complex end-to-end heterogeneous computing systems.
Extensible architecture to allow vendor and product specific EMF
model views and problem determination tasks.
Log and Trace Analyzer - Architecture
Client
Server
Log and Trace Analyzer - Importing and Monitoring
Tooling for batch importing of log and trace files into the Common Base
Event EMF models using Generic Log Adaptor static and rules parsers.
Log and trace files may be imported from the local and/or remote machine.
Real-time monitoring of Logging Agents to populate Common Base Event
EMF models.
Jakarta Apache Commons
Java Logging (JSR-047)
Jakarta Apache Log4J
Proprietary Logging Agents
Extensible architecture to allow vendor and product specific log and trace file
parser and Logging Agents.
Log and Trace Analyzer - Profiling and Logging Perspective
Set of views to display log, trace,
statistical and profiling EMF model data in
a well organized format.
Hierarchically organized by folder,
monitor, host, process and varying
agents.
Log view provides a nested tree-like
display for viewing, navigating, sorting,
filtering and searching for large amounts
of log and trace data.
UML Sequence Diagram view provides a
graphical representation of interactions.
Statistical console provides a visual
display with graphing capabilities for the
statistical EMF model.
Extensible architecture to allow users to
define vendor and product specific views.
Log and Trace Analyzer – Symptom Databases
A database consisting of matching patterns indicating known
problems, explanations and resolution steps.
Persisted as an XML file with a defined schema.
Crafted using the Symptom Database Editor in the Log and Trace
Analyzer.
Vendors and organizations may provide multiple hierarchal symptom
databases based on logical or business divisions.
Local and remote (FTP/HTTP) importing functionality to ensure
content freshness.
Log and Trace Analyzer - Analysis
Allows users to easily detect and solve problems that have already
been previously encountered.
Analysis consists of lexicographically comparing varying Common
Base Event properties with match patterns in one or more symptom
databases.
Extensible architecture to allow users to define vendor and product
specific analysis engines.
Log and Trace Analyzer - Correlation
Computing system maintainers require a detailed understanding of
an entire computing system in order to detect and resolve cascading
problems.
Correlation determines one or more sets of related events to
visualize control flow within and between computing systems.
A correlation engine or schema associates varying Common Base
Event properties based on a predetermined criteria (e.g. time).
Extensible architecture to allow users to define vendor and product
specific correlation engines or schemas.
Demonstrations
Attendees are not required to have a computer.
Configuration for attendees with computers:
Eclipse v3.1.0
TPTP v4.0.0
EMF v2.1.0
XSD v2.1.0
JRE v1.4.2 or above
Agent Controller v4.0.0
http://www.eclipse.org/tptp/ >> Latest Downloads >> 4.0.0
See the Requirements section for the Hyades dependencies.
See the Related Documents section for the release notes and installation
guide.
Demonstrations
Application used for the demonstrations consists of a simple
multi-threaded HTTP proxy server.
Architecture of the simple multi-threaded HTTP proxy server
follows a dispatcher and worker pattern.
Dispatcher threads listen to one or more ports on a given host
(e.g. local host).
Worker threads handle the individual HTTP requests for a
given dispatcher.
Profiling and Logging Perspective
The profiling tools available in the Profiling and Logging perspective
provide comprehensive information about the performance of an
application
The profiling tool (in this scenario i.e. – Java Profiling) provides
information pertaining to
JVM performance
Object allocations and references
Garbage collection
Object methods performance
Object->Object interactions
Profiling and Logging Perspective
Monitor contains
processes from hosts that
are bring monitored
Hosts being monitored
in a profiling session
Java processes
associated with a host
Profiling and Logging Perspective
Profiling and Logging perspective provides resources to
administering and managing profiling
Profiling resources are organized to provide granularity of usage
Profiling resources
Project: Make a project of your profiling effort
Monitor: Aggregate different processes and agents
Host: The host you are profiling
Process: Very simply the executing program
Agent : Provides services to a process, a mechanism by which
process data can be sent to (attached) clients
Profiling and Logging Perspective - Profiling Monitor View
A Profiling session creates numerous resources
Administer and Analyze Profiling activity
Object Control: Choice of action depending on the type of the object
Start and Stop the monitoring on an agent
Attach and Detach the agent from process
Terminate a process
Collect object reference and Run GC on a process
Context menu is resource-sensitive
Profiling and Logging Perspective - Profiling Monitor View
Project:
Container of the profiling resources
Monitor:
A logical container for the profiling information that is collected
from a group of agents. The views at the monitor level show
data from these agents. Monitors are useful for aggregating
processes and agents from a distributed application
Host:
Owns the processes that are profiled. A host runs processes.
You can specify a host either by its name or by its IP address
Process & Agent:
In the Agent Controller architecture model, an agent is a binary
file that provides services to the host process by which
Launch Configuration
Profiling Tool provides the ability to attach to a running application or
to launch an application for profiling with launch configurations
Attaching an application means that a monitor is created to contain the
results observed by an associated agent
Launch a process means that the process is started a process with an
agent associated to the process
Launch Configuration - Configurations
Attach Java Process:
local or remote
External Java Application:
local or remote
Java Applet :
workbench (local)
Java Application :
workbench (local)
Eclipse Application :
local
Other launch configurations:
for Statistical data
Host
J2EE App Server
for Test
Launch Configuration - Configuration tabs
Each type of launch configuration defines a group of tabs that collect
and display information about the configuration
Tabs for profiling:
Host tab : defines the location of the process to be launched or attached
Agents tab : used for attach launch configurations, list the agents available
for attach
Attaching to a Java Application
Attaching to a Java Application
Local Java Application
Remote Java Application
Attach to a running application or to launch an application for
profiling.
Attaching : Gather data observed by an associated agent.
Launching : the process is started with an agent associated to
the process.
Attaching to a Java Application
What is happening?
A logical representation of the Java process is created in the
Profiling Monitor view
The process object i.e. logical representation of the Java
process, is identified both by name and an ID number (PID)
that appears in the view along with the associated agents
Attaching to a Java Application
java -XrunpiAgent:server=enabled <<test>>
Start a java
program with the
profiling agent
Attach to the java
process and start
monitoring
Attaching to a Java Application - Local
Profiling and Logging
perspective to attach to a
running process locally
Attaching to a Java Application - Remote
Required to Install Eclipse Data
collection engine on the remote
machine
Host 2
Host 1
Lau nch Atta chProfiling Options
The profiling options are used
to control the type of profiling
data collected
Profiling Set
Profiling Type
Profiling Filter
Profiling Limits
Profile to File
Profiling Options - Profiling Set and Profiling Type
Specify an existing or build a
set of profiling type to control
the type of profiling data
Pre-defined Sets:
Execution history
Memory analysis
Profiling Options - Profiling Filter
Limit the classes and
method profiled
Avoid unnecessary visual
clutter and speed up the
profiling task
Profiling Options - Profiling Limits
Profiling Limits page can be
used to limit the amount of
data collected from the
application
Specify the amount of data you
want collected by specifying a
limit on method invocations or
on time.
Profiling Options - Profiling File
Route the profiling events to an
xml file instead of the profiling
views
Profiling Options - Import profiling file
Profiling file can be imported
into workbench for visual
presentation and analysis
File -> Import... -> Profile File
Select range of file to be
imported
Profiling Views
Number of views to visualize and organize profiling data
Memory Statistic view
Execution Statistic view
Coverage Statistic view
Method Invocation Detail view
Object Reference view
Execution Flow view and table
Method Invocation view and table
UML2 Trace Interactions view
Profiling Views - Statistical Views
Profiling Type oriented
Execution
Memory
Coverage
Drill down capability
Package
Class
Method
Instance
Additional Information available on
toolbar
Choose columns
Show deltas
Show as percentage
Open Source
Export to HTML
View shortcut on selection
Profiling Views - Method Invocation Detail View
Display details on a method invocation
Show invoked by and invokes information on a target method
Double click on any method in views to open view, or via context menu
entry
Traverse invocation path by updating target method in the view.
Double clicking on method interested
Profiling Views - Object Reference View
Displays references by a set of objects.
Examine data structures
Help identify memory leaks
To find unexpected references
How? Collect Object References action
Profiling Views - Execution Flow View
Give a clear global view on the
overall application execution
Analyze the application
execution at the thread level.
Threads are represented by
vertical lines
Execution stack goes from left to
right
Execution time goes from top to
bottom
Interactive: Zoom In/Out or Select
Zoom
Table format display available
below the graphical presentation.
Profiling Views - Method Invocation View
Graphical representation of the
application execution that lets you
see the method execution at the
method invocation level
Makes it easier to identify the
execution patterns and differences
between invocations of the same
method
Traverse between invocation
Show Caller or Callee
Open from any Method Selection
Table format display available
Profiling Views - Interactions Views (UML2 Trace
Interactions View)
The Interactions Views present
execution flow of an application
according to the notation
defined by UML
Host Interactions
Process Interactions
Thread Interactions
Agent Interactions
Class Interactions
Object Interactions
Profiling Views - Enabling Graphical information
Enable execution flow detail
information be loaded and
visualize in graphical views
Execution Flow View
Method Invocation View
Interactions Views
Profiling Views - Filtering Support
Statistic table views provide
filtering support
Available via toolbar drop down
action
Filter type vs Filter
Each view declares its type which is
used to associate to filter type(s)
Standard tab vs Advances tab
Standard tab provides quick start on
common attribute filtering
Advances tab provides filtering
support on profile attributes
Default filters are available for
quick start
Select filter entry from drop down
to apply
Preferences
Preferences: Customize or modify Profiling and Logging
Preferences
Enable or disable profiling or logging
Specify the port number that the agent uses to connect to the Agent
Controller
If you are working with more than one machine, use Hosts to identify
them
To identify logging agents, use Logging Agents
Associate views to Context menu of resources in the profiling
monitor view
Statistical Monitoring and Analysis
TPTP Statistical data collection agents collects the following data:
Windows System Performance Data (Perfmon)
Linux System Perfmon Data
JBoss Application Server JMX Data
JOnAS Application Server JMX Data
Apache/IHS server-status Data
MySQL Database Table and Variable Data
Various views available to control statistical agents and view statistical data
collected:
Profiling Monitor view
Agent Control views.
Statistical Graph
Statistical Monitoring and Analysis
In Profiling and Logging Perspective, launch a Statistical Agent:
Create a new Profiling Launch Configuration
Run -> Profile…
Create a new Statistical configuration
Specify the host to monitor
Specify the agent to monitor
Set additional option under configuration tabs
Settings tab
Destination tab
Common tab
Click “Profile…”
Statistical Analysis Views
Profile Monitor View
Selection in the Profiling Monitor view will be the input for statistical graph views
Agent Control View
A generic view that is able to visualize and send agent specific commands to the
data collection agents
Statistical Graph View
Graphical representation of statistical data that is returned by the agent
Statistical Graph Summaries View
Allows you to set properties of the UI representation of the data lines in the Graph
View where these properties include setting a line width, or colour.
Agent Control, Statistical Graph and Statistical Graph Summaries Views are
opened via ‘Open With’ action on selection in Profiling Monitor view.
Generic Log Adapter
Creating an Adapter File
Create a local Java Logging XML log file based on the content in Appendix 1.
Open the Generic Log Adapter Perspective (Window >> Open Perspective >>
Other… >> Generic Log Adapter).
Create a new simple project (File >> New >> Other… >> Simple >> Project).
Create a new adapter configuration file using the Adapter Configuration Editor
(File >> New >> Other… >> Generic Log Adapter >> Generic Log Adapter File).
Select the local log file as the template log file.
Start the Agent Controller (<Agent Controller install directory>/bin/RAServer.exe).
Run and debug the new adapter configuration file using the Adapter Configuration
Generic Log Adapter
Executing the Adapter File Continuously
Add a SingleFileOutputter to the Context instance to output resulting Common Base Events to
a local log file.
Move the following resources to the directory containing the adapter file:
hgla.jar (org.eclipse.hyades.logging.adapter) hlcbe101.jar (org.eclipse.hyades.logging.core) hlcore.jar (org.eclipse.hyades.logging.core) hexr.jar (org.eclipse.hyades.execution) org.eclipse.emf.ecore_2.1.0.jar org.eclipse.emf.common_2.1.0.jar /schema/* (org.eclipse.hyades.logging.adapter)
Start the Agent Controller (<Agent Controller install directory>/bin/RAServer.exe).
Run the following command from the directory containing the adapter file:
java -DGLA_HOME=<current directory> -classpath hgla.jar;hlcbe101.jar;hlcore.jar;hexr.jar; org.eclipse.emf.ecore_2.1.0.jar;org.eclipse.emf.common_2.1.0.jar
org.eclipse.hyades.logging.adapter.Adapter -ac demo.adapter -cc demo.adapter
